{"version":3,"file":"js/8956-db324e92e4c221ad6333.js","mappings":"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","sources":["webpack:///./node_modules/datatables.net-buttons/js/buttons.colVis.min.js","webpack:///./node_modules/datatables.net-buttons/js/buttons.html5.min.js","webpack:///./node_modules/datatables.net-bs5/js/dataTables.bootstrap5.mjs","webpack:///./node_modules/datatables.net-buttons-bs5/js/buttons.bootstrap5.mjs","webpack:///./node_modules/datatables.net-buttons/js/dataTables.buttons.mjs","webpack:///./node_modules/datatables.net-responsive-bs5/js/responsive.bootstrap5.mjs","webpack:///./node_modules/datatables.net-responsive/js/dataTables.responsive.mjs","webpack:///./node_modules/datatables.net-rowgroup-bs5/js/rowGroup.bootstrap5.mjs","webpack:///./node_modules/datatables.net-rowgroup/js/dataTables.rowGroup.mjs","webpack:///./node_modules/datatables.net/js/jquery.dataTables.mjs"],"sourcesContent":["/*!\n * Column visibility buttons for Buttons and DataTables.\n * © SpryMedia Ltd - datatables.net/license\n */\n!function(t){var o,i;\"function\"==typeof define&&define.amd?define([\"jquery\",\"datatables.net\",\"datatables.net-buttons\"],function(n){return t(n,window,document)}):\"object\"==typeof exports?(o=require(\"jquery\"),i=function(n,e){e.fn.dataTable||require(\"datatables.net\")(n,e),e.fn.dataTable.Buttons||require(\"datatables.net-buttons\")(n,e)},\"undefined\"==typeof window?module.exports=function(n,e){return n=n||window,e=e||o(n),i(n,e),t(e,0,n.document)}:(i(window,o),module.exports=t(o,window,window.document))):t(jQuery,window,document)}(function(n,e,t,l){\"use strict\";var o=n.fn.dataTable;return n.extend(o.ext.buttons,{colvis:function(o,i){var l=null,n={extend:\"collection\",init:function(n,e){l=e},text:function(n){return n.i18n(\"buttons.colvis\",\"Column visibility\")},className:\"buttons-colvis\",closeButton:!1,buttons:[{extend:\"columnsToggle\",columns:i.columns,columnText:i.columnText}]};return o.on(\"column-reorder.dt\"+i.namespace,function(n,e,t){o.button(null,o.button(null,l).node()).collectionRebuild([{extend:\"columnsToggle\",columns:i.columns,columnText:i.columnText}])}),n},columnsToggle:function(n,e){return n.columns(e.columns).indexes().map(function(n){return{extend:\"columnToggle\",columns:n,columnText:e.columnText}}).toArray()},columnToggle:function(n,e){return{extend:\"columnVisibility\",columns:e.columns,columnText:e.columnText}},columnsVisibility:function(n,e){return n.columns(e.columns).indexes().map(function(n){return{extend:\"columnVisibility\",columns:n,visibility:e.visibility,columnText:e.columnText}}).toArray()},columnVisibility:{columns:l,text:function(n,e,t){return t._columnText(n,t)},className:\"buttons-columnVisibility\",action:function(n,e,t,o){var e=e.columns(o.columns),i=e.visible();e.visible(o.visibility!==l?o.visibility:!(i.length&&i[0]))},init:function(o,n,i){var l=this;n.attr(\"data-cv-idx\",i.columns),o.on(\"column-visibility.dt\"+i.namespace,function(n,e){e.bDestroying||e.nTable!=o.settings()[0].nTable||l.active(o.column(i.columns).visible())}).on(\"column-reorder.dt\"+i.namespace,function(n,e,t){i.destroying||1===o.columns(i.columns).count()&&(l.text(i._columnText(o,i)),l.active(o.column(i.columns).visible()))}),this.active(o.column(i.columns).visible())},destroy:function(n,e,t){n.off(\"column-visibility.dt\"+t.namespace).off(\"column-reorder.dt\"+t.namespace)},_columnText:function(n,e){var t=n.column(e.columns).index(),o=n.settings()[0].aoColumns[t].sTitle;return o=(o=o||n.column(t).header().innerHTML).replace(/\\n/g,\" \").replace(/<br\\s*\\/?>/gi,\" \").replace(/<select(.*?)<\\/select>/g,\"\").replace(/<!\\-\\-.*?\\-\\->/g,\"\").replace(/<.*?>/g,\"\").replace(/^\\s+|\\s+$/g,\"\"),e.columnText?e.columnText(n,t,o):o}},colvisRestore:{className:\"buttons-colvisRestore\",text:function(n){return n.i18n(\"buttons.colvisRestore\",\"Restore visibility\")},init:function(e,n,t){t._visOriginal=e.columns().indexes().map(function(n){return e.column(n).visible()}).toArray()},action:function(n,e,t,o){e.columns().every(function(n){n=e.colReorder&&e.colReorder.transpose?e.colReorder.transpose(n,\"toOriginal\"):n;this.visible(o._visOriginal[n])})}},colvisGroup:{className:\"buttons-colvisGroup\",action:function(n,e,t,o){e.columns(o.show).visible(!0,!1),e.columns(o.hide).visible(!1,!1),e.columns.adjust()},show:[],hide:[]}}),o});","/*!\n * HTML5 export buttons for Buttons and DataTables.\n * © SpryMedia Ltd - datatables.net/license\n *\n * FileSaver.js (1.3.3) - MIT license\n * Copyright © 2016 Eli Grey - http://eligrey.com\n */\n!function(n){var r,a;\"function\"==typeof define&&define.amd?define([\"jquery\",\"datatables.net\",\"datatables.net-buttons\"],function(t){return n(t,window,document)}):\"object\"==typeof exports?(r=require(\"jquery\"),a=function(t,e){e.fn.dataTable||require(\"datatables.net\")(t,e),e.fn.dataTable.Buttons||require(\"datatables.net-buttons\")(t,e)},\"undefined\"==typeof window?module.exports=function(t,e,o,l){return t=t||window,e=e||r(t),a(t,e),n(e,t,t.document)}:(a(window,r),module.exports=n(r,window,window.document))):n(jQuery,window,document)}(function(C,T,y,t,e,k){\"use strict\";var o,l,n=C.fn.dataTable;function S(){return o||T.JSZip}function s(){return l||T.pdfMake}n.Buttons.pdfMake=function(t){if(!t)return s();l=t},n.Buttons.jszip=function(t){if(!t)return S();o=t};function N(t){var e=\"Sheet1\";return e=t.sheetName?t.sheetName.replace(/[\\[\\]\\*\\/\\\\\\?\\:]/g,\"\"):e}function u(t,e){for(var o=c(e),l=t.buttons.exportData(e.exportOptions),n=e.fieldBoundary,r=e.fieldSeparator,a=new RegExp(n,\"g\"),d=e.escapeChar!==k?e.escapeChar:\"\\\\\",p=function(t){for(var e=\"\",o=0,l=t.length;o<l;o++)0<o&&(e+=r),e+=n?n+(\"\"+t[o]).replace(a,d+n)+n:t[o];return e},t=e.header?p(l.header)+o:\"\",e=e.footer&&l.footer?o+p(l.footer):\"\",i=[],s=0,f=l.body.length;s<f;s++)i.push(p(l.body[s]));return{str:t+i.join(o)+e,rows:i.length}}function f(){var t;return-1!==navigator.userAgent.indexOf(\"Safari\")&&-1===navigator.userAgent.indexOf(\"Chrome\")&&-1===navigator.userAgent.indexOf(\"Opera\")&&!!((t=navigator.userAgent.match(/AppleWebKit\\/(\\d+\\.\\d+)/))&&1<t.length&&+t[1]<603.1)}var O=function(d){var p,i,s,f,m,y,e,u,c,l,t;if(!(void 0===d||\"undefined\"!=typeof navigator&&/MSIE [1-9]\\./.test(navigator.userAgent)))return t=d.document,p=function(){return d.URL||d.webkitURL||d},i=t.createElementNS(\"http://www.w3.org/1999/xhtml\",\"a\"),s=\"download\"in i,f=/constructor/i.test(d.HTMLElement)||d.safari,m=/CriOS\\/[\\d]+/.test(navigator.userAgent),y=function(t){(d.setImmediate||d.setTimeout)(function(){throw t},0)},e=4e4,u=function(t){setTimeout(function(){\"string\"==typeof t?p().revokeObjectURL(t):t.remove()},e)},c=function(t){return/^\\s*(?:text\\/\\S*|application\\/xml|\\S*\\/\\S*\\+xml)\\s*;.*charset\\s*=\\s*utf-8/i.test(t.type)?new Blob([String.fromCharCode(65279),t],{type:t.type}):t},t=(l=function(t,o,e){e||(t=c(t));var l,n,r=this,e=\"application/octet-stream\"===t.type,a=function(){for(var t=r,e=\"writestart progress write writeend\".split(\" \"),o=void 0,l=(e=[].concat(e)).length;l--;){var n=t[\"on\"+e[l]];if(\"function\"==typeof n)try{n.call(t,o||t)}catch(t){y(t)}}};r.readyState=r.INIT,s?(l=p().createObjectURL(t),setTimeout(function(){var t,e;i.href=l,i.download=o,t=i,e=new MouseEvent(\"click\"),t.dispatchEvent(e),a(),u(l),r.readyState=r.DONE})):(m||e&&f)&&d.FileReader?((n=new FileReader).onloadend=function(){var t=m?n.result:n.result.replace(/^data:[^;]*;/,\"data:attachment/file;\");d.open(t,\"_blank\")||(d.location.href=t),t=k,r.readyState=r.DONE,a()},n.readAsDataURL(t),r.readyState=r.INIT):(l=l||p().createObjectURL(t),!e&&d.open(l,\"_blank\")||(d.location.href=l),r.readyState=r.DONE,a(),u(l))}).prototype,\"undefined\"!=typeof navigator&&navigator.msSaveOrOpenBlob?function(t,e,o){return e=e||t.name||\"download\",o||(t=c(t)),navigator.msSaveOrOpenBlob(t,e)}:(t.abort=function(){},t.readyState=t.INIT=0,t.WRITING=1,t.DONE=2,t.error=t.onwritestart=t.onprogress=t.onwrite=t.onabort=t.onerror=t.onwriteend=null,function(t,e,o){return new l(t,e||t.name||\"download\",o)})}(\"undefined\"!=typeof self&&self||void 0!==T&&T||this.content),c=(n.fileSave=O,function(t){return t.newline||(navigator.userAgent.match(/Windows/)?\"\\r\\n\":\"\\n\")});function z(t){for(var e=\"A\".charCodeAt(0),o=\"Z\".charCodeAt(0)-e+1,l=\"\";0<=t;)l=String.fromCharCode(t%o+e)+l,t=Math.floor(t/o)-1;return l}try{var D,A=new XMLSerializer}catch(t){}function E(t,e,o){var l=t.createElement(e);return o&&(o.attr&&C(l).attr(o.attr),o.children&&C.each(o.children,function(t,e){l.appendChild(e)}),null!==o.text&&o.text!==k&&l.appendChild(t.createTextNode(o.text))),l}var _={\"_rels/.rels\":'<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\"><Relationship Id=\"rId1\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument\" Target=\"xl/workbook.xml\"/></Relationships>',\"xl/_rels/workbook.xml.rels\":'<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\"><Relationship Id=\"rId1\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet\" Target=\"worksheets/sheet1.xml\"/><Relationship Id=\"rId2\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles\" Target=\"styles.xml\"/></Relationships>',\"[Content_Types].xml\":'<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><Types xmlns=\"http://schemas.openxmlformats.org/package/2006/content-types\"><Default Extension=\"xml\" ContentType=\"application/xml\" /><Default Extension=\"rels\" ContentType=\"application/vnd.openxmlformats-package.relationships+xml\" /><Default Extension=\"jpeg\" ContentType=\"image/jpeg\" /><Override PartName=\"/xl/workbook.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml\" /><Override PartName=\"/xl/worksheets/sheet1.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml\" /><Override PartName=\"/xl/styles.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml\" /></Types>',\"xl/workbook.xml\":'<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><workbook xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\"><fileVersion appName=\"xl\" lastEdited=\"5\" lowestEdited=\"5\" rupBuild=\"24816\"/><workbookPr showInkAnnotation=\"0\" autoCompressPictures=\"0\"/><bookViews><workbookView xWindow=\"0\" yWindow=\"0\" windowWidth=\"25600\" windowHeight=\"19020\" tabRatio=\"500\"/></bookViews><sheets><sheet name=\"Sheet1\" sheetId=\"1\" r:id=\"rId1\"/></sheets><definedNames/></workbook>',\"xl/worksheets/sheet1.xml\":'<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><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\"><sheetData/><mergeCells count=\"0\"/></worksheet>',\"xl/styles.xml\":'<?xml version=\"1.0\" encoding=\"UTF-8\"?><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\"><numFmts count=\"6\"><numFmt numFmtId=\"164\" formatCode=\"#,##0.00_- [$$-45C]\"/><numFmt numFmtId=\"165\" formatCode=\"&quot;£&quot;#,##0.00\"/><numFmt numFmtId=\"166\" formatCode=\"[$€-2] #,##0.00\"/><numFmt numFmtId=\"167\" formatCode=\"0.0%\"/><numFmt numFmtId=\"168\" formatCode=\"#,##0;(#,##0)\"/><numFmt numFmtId=\"169\" formatCode=\"#,##0.00;(#,##0.00)\"/></numFmts><fonts count=\"5\" x14ac:knownFonts=\"1\"><font><sz val=\"11\" /><name val=\"Calibri\" /></font><font><sz val=\"11\" /><name val=\"Calibri\" /><color rgb=\"FFFFFFFF\" /></font><font><sz val=\"11\" /><name val=\"Calibri\" /><b /></font><font><sz val=\"11\" /><name val=\"Calibri\" /><i /></font><font><sz val=\"11\" /><name val=\"Calibri\" /><u /></font></fonts><fills count=\"6\"><fill><patternFill patternType=\"none\" /></fill><fill><patternFill patternType=\"none\" /></fill><fill><patternFill patternType=\"solid\"><fgColor rgb=\"FFD9D9D9\" /><bgColor indexed=\"64\" /></patternFill></fill><fill><patternFill patternType=\"solid\"><fgColor rgb=\"FFD99795\" /><bgColor indexed=\"64\" /></patternFill></fill><fill><patternFill patternType=\"solid\"><fgColor rgb=\"ffc6efce\" /><bgColor indexed=\"64\" /></patternFill></fill><fill><patternFill patternType=\"solid\"><fgColor rgb=\"ffc6cfef\" /><bgColor indexed=\"64\" /></patternFill></fill></fills><borders count=\"2\"><border><left /><right /><top /><bottom /><diagonal /></border><border diagonalUp=\"false\" diagonalDown=\"false\"><left style=\"thin\"><color auto=\"1\" /></left><right style=\"thin\"><color auto=\"1\" /></right><top style=\"thin\"><color auto=\"1\" /></top><bottom style=\"thin\"><color auto=\"1\" /></bottom><diagonal /></border></borders><cellStyleXfs count=\"1\"><xf numFmtId=\"0\" fontId=\"0\" fillId=\"0\" borderId=\"0\" /></cellStyleXfs><cellXfs count=\"68\"><xf numFmtId=\"0\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"1\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"2\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"3\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"4\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"0\" fillId=\"2\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"1\" fillId=\"2\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"2\" fillId=\"2\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"3\" fillId=\"2\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"4\" fillId=\"2\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"0\" fillId=\"3\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"1\" fillId=\"3\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"2\" fillId=\"3\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"3\" fillId=\"3\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"4\" fillId=\"3\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"0\" fillId=\"4\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"1\" fillId=\"4\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"2\" fillId=\"4\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"3\" fillId=\"4\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"4\" fillId=\"4\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"0\" fillId=\"5\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"1\" fillId=\"5\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"2\" fillId=\"5\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"3\" fillId=\"5\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"4\" fillId=\"5\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"0\" fillId=\"0\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"1\" fillId=\"0\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"2\" fillId=\"0\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"3\" fillId=\"0\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"4\" fillId=\"0\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"0\" fillId=\"2\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"1\" fillId=\"2\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"2\" fillId=\"2\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"3\" fillId=\"2\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"4\" fillId=\"2\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"0\" fillId=\"3\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"1\" fillId=\"3\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"2\" fillId=\"3\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"3\" fillId=\"3\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"4\" fillId=\"3\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"0\" fillId=\"4\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"1\" fillId=\"4\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"2\" fillId=\"4\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"3\" fillId=\"4\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"4\" fillId=\"4\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"0\" fillId=\"5\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"1\" fillId=\"5\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"2\" fillId=\"5\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"3\" fillId=\"5\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"4\" fillId=\"5\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/><xf numFmtId=\"0\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyAlignment=\"1\"><alignment horizontal=\"left\"/></xf><xf numFmtId=\"0\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyAlignment=\"1\"><alignment horizontal=\"center\"/></xf><xf numFmtId=\"0\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyAlignment=\"1\"><alignment horizontal=\"right\"/></xf><xf numFmtId=\"0\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyAlignment=\"1\"><alignment horizontal=\"fill\"/></xf><xf numFmtId=\"0\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyAlignment=\"1\"><alignment textRotation=\"90\"/></xf><xf numFmtId=\"0\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyAlignment=\"1\"><alignment wrapText=\"1\"/></xf><xf numFmtId=\"9\"   fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyNumberFormat=\"1\"/><xf numFmtId=\"164\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyNumberFormat=\"1\"/><xf numFmtId=\"165\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyNumberFormat=\"1\"/><xf numFmtId=\"166\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyNumberFormat=\"1\"/><xf numFmtId=\"167\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyNumberFormat=\"1\"/><xf numFmtId=\"168\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyNumberFormat=\"1\"/><xf numFmtId=\"169\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyNumberFormat=\"1\"/><xf numFmtId=\"3\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyNumberFormat=\"1\"/><xf numFmtId=\"4\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyNumberFormat=\"1\"/><xf numFmtId=\"1\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyNumberFormat=\"1\"/><xf numFmtId=\"2\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyNumberFormat=\"1\"/><xf numFmtId=\"14\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyNumberFormat=\"1\"/></cellXfs><cellStyles count=\"1\"><cellStyle name=\"Normal\" xfId=\"0\" builtinId=\"0\" /></cellStyles><dxfs count=\"0\" /><tableStyles count=\"0\" defaultTableStyle=\"TableStyleMedium9\" defaultPivotStyle=\"PivotStyleMedium4\" /></styleSheet>'},R=[{match:/^\\-?\\d+\\.\\d%$/,style:60,fmt:function(t){return t/100}},{match:/^\\-?\\d+\\.?\\d*%$/,style:56,fmt:function(t){return t/100}},{match:/^\\-?\\$[\\d,]+.?\\d*$/,style:57},{match:/^\\-?£[\\d,]+.?\\d*$/,style:58},{match:/^\\-?€[\\d,]+.?\\d*$/,style:59},{match:/^\\-?\\d+$/,style:65},{match:/^\\-?\\d+\\.\\d{2}$/,style:66},{match:/^\\([\\d,]+\\)$/,style:61,fmt:function(t){return-1*t.replace(/[\\(\\)]/g,\"\")}},{match:/^\\([\\d,]+\\.\\d{2}\\)$/,style:62,fmt:function(t){return-1*t.replace(/[\\(\\)]/g,\"\")}},{match:/^\\-?[\\d,]+$/,style:63},{match:/^\\-?[\\d,]+\\.\\d{2}$/,style:64},{match:/^[\\d]{4}\\-[01][\\d]\\-[0123][\\d]$/,style:67,fmt:function(t){return Math.round(25569+Date.parse(t)/864e5)}}];return n.ext.buttons.copyHtml5={className:\"buttons-copy buttons-html5\",text:function(t){return t.i18n(\"buttons.copy\",\"Copy\")},action:function(t,e,o,l){this.processing(!0);var n=this,r=u(e,l),a=e.buttons.exportInfo(l),d=c(l),p=r.str,i=C(\"<div/>\").css({height:1,width:1,overflow:\"hidden\",position:\"fixed\",top:0,left:0}),d=(a.title&&(p=a.title+d+d+p),a.messageTop&&(p=a.messageTop+d+d+p),a.messageBottom&&(p=p+d+d+a.messageBottom),l.customize&&(p=l.customize(p,l,e)),C(\"<textarea readonly/>\").val(p).appendTo(i));if(y.queryCommandSupported(\"copy\")){i.appendTo(e.table().container()),d[0].focus(),d[0].select();try{var s=y.execCommand(\"copy\");if(i.remove(),s)return e.buttons.info(e.i18n(\"buttons.copyTitle\",\"Copy to clipboard\"),e.i18n(\"buttons.copySuccess\",{1:\"Copied one row to clipboard\",_:\"Copied %d rows to clipboard\"},r.rows),2e3),void this.processing(!1)}catch(t){}}function f(){m.off(\"click.buttons-copy\"),C(y).off(\".buttons-copy\"),e.buttons.info(!1)}var a=C(\"<span>\"+e.i18n(\"buttons.copyKeys\",\"Press <i>ctrl</i> or <i>⌘</i> + <i>C</i> to copy the table data<br>to your system clipboard.<br><br>To cancel, click this message or press escape.\")+\"</span>\").append(i),m=(e.buttons.info(e.i18n(\"buttons.copyTitle\",\"Copy to clipboard\"),a,0),d[0].focus(),d[0].select(),C(a).closest(\".dt-button-info\"));m.on(\"click.buttons-copy\",f),C(y).on(\"keydown.buttons-copy\",function(t){27===t.keyCode&&(f(),n.processing(!1))}).on(\"copy.buttons-copy cut.buttons-copy\",function(){f(),n.processing(!1)})},exportOptions:{},fieldSeparator:\"\\t\",fieldBoundary:\"\",header:!0,footer:!1,title:\"*\",messageTop:\"*\",messageBottom:\"*\"},n.ext.buttons.csvHtml5={bom:!1,className:\"buttons-csv buttons-html5\",available:function(){return T.FileReader!==k&&T.Blob},text:function(t){return t.i18n(\"buttons.csv\",\"CSV\")},action:function(t,e,o,l){this.processing(!0);var n=u(e,l).str,r=e.buttons.exportInfo(l),a=l.charset;l.customize&&(n=l.customize(n,l,e)),a=!1!==a?(a=a||y.characterSet||y.charset)&&\";charset=\"+a:\"\",l.bom&&(n=String.fromCharCode(65279)+n),O(new Blob([n],{type:\"text/csv\"+a}),r.filename,!0),this.processing(!1)},filename:\"*\",extension:\".csv\",exportOptions:{},fieldSeparator:\",\",fieldBoundary:'\"',escapeChar:'\"',charset:null,header:!0,footer:!1},n.ext.buttons.excelHtml5={className:\"buttons-excel buttons-html5\",available:function(){return T.FileReader!==k&&S()!==k&&!f()&&A},text:function(t){return t.i18n(\"buttons.excel\",\"Excel\")},action:function(t,e,o,s){this.processing(!0);function l(t){return t=_[t],C.parseXML(t)}function n(t){m=E(u,\"row\",{attr:{r:f=y+1}});for(var e=0,o=t.length;e<o;e++){var l=z(e)+\"\"+f,n=null;if(null===t[e]||t[e]===k||\"\"===t[e]){if(!0!==s.createEmptyCells)continue;t[e]=\"\"}var r=t[e];t[e]=\"function\"==typeof t[e].trim?t[e].trim():t[e];for(var a=0,d=R.length;a<d;a++){var p=R[a];if(t[e].match&&!t[e].match(/^0\\d+/)&&t[e].match(p.match)){var i=t[e].replace(/[^\\d\\.\\-]/g,\"\");p.fmt&&(i=p.fmt(i)),n=E(u,\"c\",{attr:{r:l,s:p.style},children:[E(u,\"v\",{text:i})]});break}}n=n||(\"number\"==typeof t[e]||t[e].match&&t[e].match(/^-?\\d+(\\.\\d+)?([eE]\\-?\\d+)?$/)&&!t[e].match(/^0\\d+/)?E(u,\"c\",{attr:{t:\"n\",r:l},children:[E(u,\"v\",{text:t[e]})]}):(r=r.replace?r.replace(/[\\x00-\\x09\\x0B\\x0C\\x0E-\\x1F\\x7F-\\x9F]/g,\"\"):r,E(u,\"c\",{attr:{t:\"inlineStr\",r:l},children:{row:E(u,\"is\",{children:{row:E(u,\"t\",{text:r,attr:{\"xml:space\":\"preserve\"}})}})}}))),m.appendChild(n)}c.appendChild(m),y++}function r(t,e){var o=C(\"mergeCells\",u);o[0].appendChild(E(u,\"mergeCell\",{attr:{ref:\"A\"+t+\":\"+z(e)+t}})),o.attr(\"count\",parseFloat(o.attr(\"count\"))+1),C(\"row:eq(\"+(t-1)+\") c\",u).attr(\"s\",\"51\")}var a,f,m,d=this,y=0,u=l(\"xl/worksheets/sheet1.xml\"),c=u.getElementsByTagName(\"sheetData\")[0],p={_rels:{\".rels\":l(\"_rels/.rels\")},xl:{_rels:{\"workbook.xml.rels\":l(\"xl/_rels/workbook.xml.rels\")},\"workbook.xml\":l(\"xl/workbook.xml\"),\"styles.xml\":l(\"xl/styles.xml\"),worksheets:{\"sheet1.xml\":u}},\"[Content_Types].xml\":l(\"[Content_Types].xml\")},i=e.buttons.exportData(s.exportOptions),I=(s.customizeData&&s.customizeData(i),e.buttons.exportInfo(s));I.title&&(n([I.title]),r(y,i.header.length-1)),I.messageTop&&(n([I.messageTop]),r(y,i.header.length-1)),s.header&&(n(i.header),C(\"row:last c\",u).attr(\"s\",\"2\"));for(var F=y,x=0,h=i.body.length;x<h;x++)n(i.body[x]);a=y,s.footer&&i.footer&&(n(i.footer),C(\"row:last c\",u).attr(\"s\",\"2\")),I.messageBottom&&(n([I.messageBottom]),r(y,i.header.length-1));var b=E(u,\"cols\");C(\"worksheet\",u).prepend(b);for(var g=0,v=i.header.length;g<v;g++)b.appendChild(E(u,\"col\",{attr:{min:g+1,max:g+1,width:function(t,e){var o=t.header[e].length;t.footer&&t.footer[e].length>o&&(o=t.footer[e].length);for(var l=0,n=t.body.length;l<n;l++){var r,a=t.body[l][e];if(40<(o=o<(r=(-1!==(a=null!==a&&a!==k?a.toString():\"\").indexOf(\"\\n\")?((r=a.split(\"\\n\")).sort(function(t,e){return e.length-t.length}),r[0]):a).length)?r:o))return 54}return 6<(o*=1.35)?o:6}(i,g),customWidth:1}}));var w=p.xl[\"workbook.xml\"];C(\"sheets sheet\",w).attr(\"name\",N(s)),s.autoFilter&&(C(\"mergeCells\",u).before(E(u,\"autoFilter\",{attr:{ref:\"A\"+F+\":\"+z(i.header.length-1)+a}})),C(\"definedNames\",w).append(E(w,\"definedName\",{attr:{name:\"_xlnm._FilterDatabase\",localSheetId:\"0\",hidden:1},text:N(s)+\"!$A$\"+F+\":\"+z(i.header.length-1)+a}))),s.customize&&s.customize(p,s,e),0===C(\"mergeCells\",u).children().length&&C(\"mergeCells\",u).remove();var w=new(S()),F={compression:\"DEFLATE\",type:\"blob\",mimeType:\"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet\"},B=(!function s(f,t){D===k&&(D=-1===A.serializeToString((new T.DOMParser).parseFromString(_[\"xl/worksheets/sheet1.xml\"],\"text/xml\")).indexOf(\"xmlns:r\")),C.each(t,function(t,e){if(C.isPlainObject(e))s(f.folder(t),e);else{if(D){for(var o,l=e.childNodes[0],n=[],r=l.attributes.length-1;0<=r;r--){var a=l.attributes[r].nodeName,d=l.attributes[r].nodeValue;-1!==a.indexOf(\":\")&&(n.push({name:a,value:d}),l.removeAttribute(a))}for(r=0,o=n.length;r<o;r++){var p=e.createAttribute(n[r].name.replace(\":\",\"_dt_b_namespace_token_\"));p.value=n[r].value,l.setAttributeNode(p)}}var i=A.serializeToString(e),i=(i=D?(i=(i=-1===i.indexOf(\"<?xml\")?'<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>'+i:i).replace(/_dt_b_namespace_token_/g,\":\")).replace(/xmlns:NS[\\d]+=\"\" NS[\\d]+:/g,\"\"):i).replace(/<([^<>]*?) xmlns=\"\"([^<>]*?)>/g,\"<$1 $2>\");f.file(t,i)}})}(w,p),I.filename);175<B&&(B=B.substr(0,175)),w.generateAsync?w.generateAsync(F).then(function(t){O(t,B),d.processing(!1)}):(O(w.generate(F),B),this.processing(!1))},filename:\"*\",extension:\".xlsx\",exportOptions:{},header:!0,footer:!1,title:\"*\",messageTop:\"*\",messageBottom:\"*\",createEmptyCells:!1,autoFilter:!1,sheetName:\"\"},n.ext.buttons.pdfHtml5={className:\"buttons-pdf buttons-html5\",available:function(){return T.FileReader!==k&&s()},text:function(t){return t.i18n(\"buttons.pdf\",\"PDF\")},action:function(t,e,o,l){this.processing(!0);var n=e.buttons.exportData(l.exportOptions),r=e.buttons.exportInfo(l),a=[];l.header&&a.push(C.map(n.header,function(t){return{text:\"string\"==typeof t?t:t+\"\",style:\"tableHeader\"}}));for(var d=0,p=n.body.length;d<p;d++)a.push(C.map(n.body[d],function(t){return{text:\"string\"==typeof(t=null!==t&&t!==k?t:\"\")?t:t+\"\",style:d%2?\"tableBodyEven\":\"tableBodyOdd\"}}));l.footer&&n.footer&&a.push(C.map(n.footer,function(t){return{text:\"string\"==typeof t?t:t+\"\",style:\"tableFooter\"}}));var i={pageSize:l.pageSize,pageOrientation:l.orientation,content:[{table:{headerRows:1,body:a},layout:\"noBorders\"}],styles:{tableHeader:{bold:!0,fontSize:11,color:\"white\",fillColor:\"#2d4154\",alignment:\"center\"},tableBodyEven:{},tableBodyOdd:{fillColor:\"#f3f3f3\"},tableFooter:{bold:!0,fontSize:11,color:\"white\",fillColor:\"#2d4154\"},title:{alignment:\"center\",fontSize:15},message:{}},defaultStyle:{fontSize:10}},e=(r.messageTop&&i.content.unshift({text:r.messageTop,style:\"message\",margin:[0,0,0,12]}),r.messageBottom&&i.content.push({text:r.messageBottom,style:\"message\",margin:[0,0,0,12]}),r.title&&i.content.unshift({text:r.title,style:\"title\",margin:[0,0,0,12]}),l.customize&&l.customize(i,l,e),s().createPdf(i));\"open\"!==l.download||f()?e.download(r.filename):e.open(),this.processing(!1)},title:\"*\",filename:\"*\",extension:\".pdf\",exportOptions:{},orientation:\"portrait\",pageSize:\"A4\",header:!0,footer:!1,messageTop:\"*\",messageBottom:\"*\",customize:null,download:\"download\"},n});","/*! DataTables Bootstrap 5 integration\n * 2020 SpryMedia Ltd - datatables.net/license\n */\n\nimport jQuery from 'jquery';\nimport DataTable from 'datatables.net';\n\n// Allow reassignment of the $ variable\nlet $ = jQuery;\n\n\n/**\n * DataTables integration for Bootstrap 5. This requires Bootstrap 5 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 https://datatables.net/manual/styling/bootstrap\n * for further information.\n */\n\n/* Set the defaults for DataTables initialisation */\n$.extend( true, DataTable.defaults, {\n\tdom:\n\t\t\"<'row'<'col-sm-12 col-md-6'l><'col-sm-12 col-md-6'f>>\" +\n\t\t\"<'row dt-row'<'col-sm-12'tr>>\" +\n\t\t\"<'row'<'col-sm-12 col-md-5'i><'col-sm-12 col-md-7'p>>\",\n\trenderer: 'bootstrap'\n} );\n\n\n/* Default class modification */\n$.extend( DataTable.ext.classes, {\n\tsWrapper:      \"dataTables_wrapper dt-bootstrap5\",\n\tsFilterInput:  \"form-control form-control-sm\",\n\tsLengthSelect: \"form-select form-select-sm\",\n\tsProcessing:   \"dataTables_processing card\",\n\tsPageButton:   \"paginate_button page-item\"\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;\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 ( Array.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\tvar disabled = btnClass.indexOf('disabled') !== -1;\n\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': disabled ? null : '#',\n\t\t\t\t\t\t\t\t'aria-controls': settings.sTableId,\n\t\t\t\t\t\t\t\t'aria-disabled': disabled ? 'true' : null,\n\t\t\t\t\t\t\t\t'aria-label': aria[ button ],\n\t\t\t\t\t\t\t\t'role': 'link',\n\t\t\t\t\t\t\t\t'aria-current': btnClass === 'active' ? 'page' : null,\n\t\t\t\t\t\t\t\t'data-dt-idx': button,\n\t\t\t\t\t\t\t\t'tabindex': disabled ? -1 : settings.iTabIndex,\n\t\t\t\t\t\t\t\t'class': 'page-link'\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\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n\n\tvar hostEl = $(host);\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 = hostEl.find(document.activeElement).data('dt-idx');\n\t}\n\tcatch (e) {}\n\n\tvar paginationEl = hostEl.children('ul.pagination');\n\n\tif (paginationEl.length) {\n\t\tpaginationEl.empty();\n\t}\n\telse {\n\t\tpaginationEl = hostEl.html('<ul/>').children('ul').addClass('pagination');\n\t}\n\n\tattach(\n\t\tpaginationEl,\n\t\tbuttons\n\t);\n\n\tif ( activeEl !== undefined ) {\n\t\thostEl.find('[data-dt-idx='+activeEl+']').trigger('focus');\n\t}\n};\n\n\nexport default DataTable;\n","/*! Bootstrap integration for DataTables' Buttons\n * © SpryMedia Ltd - datatables.net/license\n */\n\nimport jQuery from 'jquery';\nimport DataTable from 'datatables.net-bs5';\nimport Buttons from 'datatables.net-buttons';\n\n// Allow reassignment of the $ variable\nlet $ = jQuery;\n\n\n$.extend(true, DataTable.Buttons.defaults, {\n\tdom: {\n\t\tcontainer: {\n\t\t\tclassName: 'dt-buttons btn-group flex-wrap'\n\t\t},\n\t\tbutton: {\n\t\t\tclassName: 'btn btn-secondary',\n\t\t\tactive: 'active'\n\t\t},\n\t\tcollection: {\n\t\t\taction: {\n\t\t\t\tdropHtml: ''\n\t\t\t},\n\t\t\tcontainer: {\n\t\t\t\ttag: 'div',\n\t\t\t\tclassName: 'dropdown-menu dt-button-collection'\n\t\t\t},\n\t\t\tcloseButton: false,\n\t\t\tbutton: {\n\t\t\t\ttag: 'a',\n\t\t\t\tclassName: 'dt-button dropdown-item',\n\t\t\t\tactive: 'dt-button-active',\n\t\t\t\tdisabled: 'disabled',\n\t\t\t\tspacer: {\n\t\t\t\t\tclassName: 'dropdown-divider',\n\t\t\t\t\ttag: 'hr'\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\tsplit: {\n\t\t\taction: {\n\t\t\t\ttag: 'a',\n\t\t\t\tclassName: 'btn btn-secondary dt-button-split-drop-button',\n\t\t\t\tcloseButton: false\n\t\t\t},\n\t\t\tdropdown: {\n\t\t\t\ttag: 'button',\n\t\t\t\tdropHtml: '',\n\t\t\t\tclassName:\n\t\t\t\t\t'btn btn-secondary dt-button-split-drop dropdown-toggle dropdown-toggle-split',\n\t\t\t\tcloseButton: false,\n\t\t\t\talign: 'split-left',\n\t\t\t\tsplitAlignClass: 'dt-button-split-left'\n\t\t\t},\n\t\t\twrapper: {\n\t\t\t\ttag: 'div',\n\t\t\t\tclassName: 'dt-button-split btn-group',\n\t\t\t\tcloseButton: false\n\t\t\t}\n\t\t}\n\t},\n\tbuttonCreated: function (config, button) {\n\t\treturn config.buttons ? $('<div class=\"btn-group\"/>').append(button) : button;\n\t}\n});\n\nDataTable.ext.buttons.collection.className += ' dropdown-toggle';\nDataTable.ext.buttons.collection.rightAlignClassName = 'dropdown-menu-right';\n\n\nexport default DataTable;\n","/*! Buttons for DataTables 2.4.1\n * © SpryMedia Ltd - datatables.net/license\n */\n\nimport jQuery from 'jquery';\nimport DataTable from 'datatables.net';\n\n// Allow reassignment of the $ variable\nlet $ = jQuery;\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// Allow for jQuery slim\nfunction _fadeIn(el, duration, fn) {\n\tif ($.fn.animate) {\n\t\tel.stop().fadeIn(duration, fn);\n\t}\n\telse {\n\t\tel.css('display', 'block');\n\n\t\tif (fn) {\n\t\t\tfn.call(el);\n\t\t}\n\t}\n}\n\nfunction _fadeOut(el, duration, fn) {\n\tif ($.fn.animate) {\n\t\tel.stop().fadeOut(duration, fn);\n\t}\n\telse {\n\t\tel.css('display', 'none');\n\n\t\tif (fn) {\n\t\t\tfn.call(el);\n\t\t}\n\t}\n}\n\n/**\n * [Buttons description]\n * @param {[type]}\n * @param {[type]}\n */\nvar Buttons = function (dt, config) {\n\t// If not created with a `new` keyword then we return a wrapper function that\n\t// will take the settings object for a DT. This allows easy use of new instances\n\t// with the `layout` option - e.g. `topLeft: $.fn.dataTable.Buttons( ... )`.\n\tif (!(this instanceof Buttons)) {\n\t\treturn function (settings) {\n\t\t\treturn new Buttons(settings, dt).container();\n\t\t};\n\t}\n\n\t// If there is no config set it to an empty object\n\tif (typeof config === 'undefined') {\n\t\tconfig = {};\n\t}\n\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 (Array.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 + '/>').addClass(this.c.dom.container.className)\n\t};\n\n\tthis._constructor();\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\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 (\n\t\t\tbutton.inCollection &&\n\t\t\tthis.c.dom.collection.button &&\n\t\t\tthis.c.dom.collection.button.active !== undefined\n\t\t) {\n\t\t\tklass = this.c.dom.collection.button.active;\n\t\t}\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 * @param {boolean} [draw=true] Trigger a draw. Set a false when adding\n\t *   lots of buttons, until the last button.\n\t * @return {Buttons} Self for chaining\n\t */\n\tadd: function (config, idx, draw) {\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(\n\t\t\tbuttons,\n\t\t\tconfig,\n\t\t\tconfig !== undefined ? config.split : undefined,\n\t\t\t(config === undefined || config.split === undefined || config.split.length === 0) &&\n\t\t\t\tbase !== undefined,\n\t\t\tfalse,\n\t\t\tidx\n\t\t);\n\n\t\tif (draw === undefined || draw === true) {\n\t\t\tthis._draw();\n\t\t}\n\n\t\treturn this;\n\t},\n\n\t/**\n\t * Clear buttons from a collection and then insert new buttons\n\t */\n\tcollectionRebuild: function (node, newButtons) {\n\t\tvar button = this._nodeToButton(node);\n\n\t\tif (newButtons !== undefined) {\n\t\t\tvar i;\n\t\t\t// Need to reverse the array\n\t\t\tfor (i = button.buttons.length - 1; i >= 0; i--) {\n\t\t\t\tthis.remove(button.buttons[i].node);\n\t\t\t}\n\n\t\t\t// If the collection has prefix and / or postfix buttons we need to add them in\n\t\t\tif (button.conf.prefixButtons) {\n\t\t\t\tnewButtons.unshift.apply(newButtons, button.conf.prefixButtons);\n\t\t\t}\n\n\t\t\tif (button.conf.postfixButtons) {\n\t\t\t\tnewButtons.push.apply(newButtons, button.conf.postfixButtons);\n\t\t\t}\n\n\t\t\tfor (i = 0; i < newButtons.length; i++) {\n\t\t\t\tvar newBtn = newButtons[i];\n\n\t\t\t\tthis._expandButton(\n\t\t\t\t\tbutton.buttons,\n\t\t\t\t\tnewBtn,\n\t\t\t\t\tnewBtn !== undefined &&\n\t\t\t\t\t\tnewBtn.config !== undefined &&\n\t\t\t\t\t\tnewBtn.config.split !== undefined,\n\t\t\t\t\ttrue,\n\t\t\t\t\tnewBtn.parentConf !== undefined && newBtn.parentConf.split !== undefined,\n\t\t\t\t\tnull,\n\t\t\t\t\tnewBtn.parentConf\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\n\t\tthis._draw(button.collection, button.buttons);\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\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).prop('disabled', true);\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\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\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\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).prop('disabled', false);\n\n\t\treturn this;\n\t},\n\n\t/**\n\t * Get a button's index\n\t *\n\t * This is internally recursive\n\t * @param {element} node Button to get the index of\n\t * @return {string} Button index\n\t */\n\tindex: function (node, nested, buttons) {\n\t\tif (!nested) {\n\t\t\tnested = '';\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\tvar inner = buttons[i].buttons;\n\n\t\t\tif (buttons[i].node === node) {\n\t\t\t\treturn nested + i;\n\t\t\t}\n\n\t\t\tif (inner && inner.length) {\n\t\t\t\tvar match = this.index(node, i + '-', inner);\n\n\t\t\t\tif (match !== null) {\n\t\t\t\t\treturn match;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn null;\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\treturn this.c.name;\n\t},\n\n\t/**\n\t * Get a button's node of the buttons container if no button is given\n\t * @param  {node} [node] Button node\n\t * @return {jQuery} Button element, or container\n\t */\n\tnode: function (node) {\n\t\tif (!node) {\n\t\t\treturn this.dom.container;\n\t\t}\n\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 {element} node Triggering button node\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\tvar dt = this.s.dt;\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\t$(dt.table().node()).triggerHandler('buttons-processing.dt', [\n\t\t\tflag,\n\t\t\tdt.button(node),\n\t\t\tdt,\n\t\t\t$(node),\n\t\t\tbutton.conf\n\t\t]);\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\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\tbutton.conf.destroying = true;\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\tvar button = this._nodeToButton(node);\n\t\tvar textNode = button.textNode;\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' ? opt(dt, jqNode, button.conf) : opt;\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\t\ttextNode.html(text(label));\n\n\t\treturn this;\n\t},\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\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 (e, settings) {\n\t\t\tif (settings === dtSettings) {\n\t\t\t\tthat.destroy();\n\t\t\t}\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\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\tif (conf.key) {\n\t\t\tthis.s.listenKeys += $.isPlainObject(conf.key) ? conf.key.key : conf.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\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 (\n\t\tattachTo,\n\t\tbutton,\n\t\tsplit,\n\t\tinCollection,\n\t\tinSplit,\n\t\tattachPoint,\n\t\tparentConf\n\t) {\n\t\tvar dt = this.s.dt;\n\t\tvar isSplit = false;\n\t\tvar domCollection = this.c.dom.collection;\n\t\tvar buttons = !Array.isArray(button) ? [button] : button;\n\n\t\tif (button === undefined) {\n\t\t\tbuttons = !Array.isArray(split) ? [split] : split;\n\t\t}\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\tisSplit = conf.config && conf.config.split ? true : false;\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 (Array.isArray(conf)) {\n\t\t\t\tthis._expandButton(\n\t\t\t\t\tattachTo,\n\t\t\t\t\tconf,\n\t\t\t\t\tbuilt !== undefined && built.conf !== undefined ? built.conf.split : undefined,\n\t\t\t\t\tinCollection,\n\t\t\t\t\tparentConf !== undefined && parentConf.split !== undefined,\n\t\t\t\t\tattachPoint,\n\t\t\t\t\tparentConf\n\t\t\t\t);\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tvar built = this._buildButton(\n\t\t\t\tconf,\n\t\t\t\tinCollection,\n\t\t\t\tconf.split !== undefined ||\n\t\t\t\t\t(conf.config !== undefined && conf.config.split !== undefined),\n\t\t\t\tinSplit\n\t\t\t);\n\t\t\tif (!built) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tif (attachPoint !== undefined && attachPoint !== null) {\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\t// Create the dropdown for a collection\n\t\t\tif (built.conf.buttons) {\n\t\t\t\tbuilt.collection = $('<' + domCollection.container.content.tag + '/>');\n\t\t\t\tbuilt.conf._collection = built.collection;\n\n\t\t\t\t$(built.node).append(domCollection.action.dropHtml);\n\n\t\t\t\tthis._expandButton(\n\t\t\t\t\tbuilt.buttons,\n\t\t\t\t\tbuilt.conf.buttons,\n\t\t\t\t\tbuilt.conf.split,\n\t\t\t\t\t!isSplit,\n\t\t\t\t\tisSplit,\n\t\t\t\t\tattachPoint,\n\t\t\t\t\tbuilt.conf\n\t\t\t\t);\n\t\t\t}\n\n\t\t\t// And the split collection\n\t\t\tif (built.conf.split) {\n\t\t\t\tbuilt.collection = $('<' + domCollection.container.tag + '/>');\n\t\t\t\tbuilt.conf._collection = built.collection;\n\n\t\t\t\tfor (var j = 0; j < built.conf.split.length; j++) {\n\t\t\t\t\tvar item = built.conf.split[j];\n\n\t\t\t\t\tif (typeof item === 'object') {\n\t\t\t\t\t\titem.parent = parentConf;\n\n\t\t\t\t\t\tif (item.collectionLayout === undefined) {\n\t\t\t\t\t\t\titem.collectionLayout = built.conf.collectionLayout;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tif (item.dropup === undefined) {\n\t\t\t\t\t\t\titem.dropup = built.conf.dropup;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tif (item.fade === undefined) {\n\t\t\t\t\t\t\titem.fade = built.conf.fade;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tthis._expandButton(\n\t\t\t\t\tbuilt.buttons,\n\t\t\t\t\tbuilt.conf.buttons,\n\t\t\t\t\tbuilt.conf.split,\n\t\t\t\t\t!isSplit,\n\t\t\t\t\tisSplit,\n\t\t\t\t\tattachPoint,\n\t\t\t\t\tbuilt.conf\n\t\t\t\t);\n\t\t\t}\n\n\t\t\tbuilt.conf.parent = parentConf;\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\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 {object} Completed button description object\n\t * @private\n\t */\n\t_buildButton: function (config, inCollection, isSplit, inSplit) {\n\t\tvar configDom = this.c.dom;\n\t\tvar textNode;\n\t\tvar dt = this.s.dt;\n\t\tvar text = function (opt) {\n\t\t\treturn typeof opt === 'function' ? opt(dt, button, config) : opt;\n\t\t};\n\n\t\t// Create an object that describes the button which can be in `dom.button`, or\n\t\t// `dom.collection.button` or `dom.split.button` or `dom.collection.split.button`!\n\t\t// Each should extend from `dom.button`.\n\t\tvar dom = $.extend(true, {}, configDom.button);\n\n\t\tif (inCollection && isSplit && configDom.collection.split) {\n\t\t\t$.extend(true, dom, configDom.collection.split.action);\n\t\t}\n\t\telse if (inSplit || inCollection) {\n\t\t\t$.extend(true, dom, configDom.collection.button);\n\t\t}\n\t\telse if (isSplit) {\n\t\t\t$.extend(true, dom, configDom.split.button);\n\t\t}\n\n\t\t// Spacers don't do much other than insert an element into the DOM\n\t\tif (config.spacer) {\n\t\t\tvar spacer = $('<' + dom.spacer.tag + '/>')\n\t\t\t\t.addClass('dt-button-spacer ' + config.style + ' ' + dom.spacer.className)\n\t\t\t\t.html(text(config.text));\n\n\t\t\treturn {\n\t\t\t\tconf: config,\n\t\t\t\tnode: spacer,\n\t\t\t\tinserter: spacer,\n\t\t\t\tbuttons: [],\n\t\t\t\tinCollection: inCollection,\n\t\t\t\tisSplit: isSplit,\n\t\t\t\tcollection: null,\n\t\t\t\ttextNode: spacer\n\t\t\t};\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, PDF button require pdfmake\n\t\tif (config.available && !config.available(dt, config) && !config.hasOwnProperty('html')) {\n\t\t\treturn false;\n\t\t}\n\n\t\tvar button;\n\n\t\tif (!config.hasOwnProperty('html')) {\n\t\t\tvar action = function (e, dt, button, config) {\n\t\t\t\tconfig.action.call(dt.button(button), e, dt, button, config);\n\n\t\t\t\t$(dt.table().node()).triggerHandler('buttons-action.dt', [\n\t\t\t\t\tdt.button(button),\n\t\t\t\t\tdt,\n\t\t\t\t\tbutton,\n\t\t\t\t\tconfig\n\t\t\t\t]);\n\t\t\t};\n\n\t\t\tvar tag = config.tag || dom.tag;\n\t\t\tvar clickBlurs = config.clickBlurs === undefined ? true : config.clickBlurs;\n\n\t\t\tbutton = $('<' + tag + '/>')\n\t\t\t\t.addClass(dom.className)\n\t\t\t\t.attr('tabindex', this.s.dt.settings()[0].iTabIndex)\n\t\t\t\t.attr('aria-controls', this.s.dt.table().node().id)\n\t\t\t\t.on('click.dtb', function (e) {\n\t\t\t\t\te.preventDefault();\n\n\t\t\t\t\tif (!button.hasClass(dom.disabled) && config.action) {\n\t\t\t\t\t\taction(e, dt, button, config);\n\t\t\t\t\t}\n\n\t\t\t\t\tif (clickBlurs) {\n\t\t\t\t\t\tbutton.trigger('blur');\n\t\t\t\t\t}\n\t\t\t\t})\n\t\t\t\t.on('keypress.dtb', function (e) {\n\t\t\t\t\tif (e.keyCode === 13) {\n\t\t\t\t\t\te.preventDefault();\n\n\t\t\t\t\t\tif (!button.hasClass(dom.disabled) && config.action) {\n\t\t\t\t\t\t\taction(e, dt, button, config);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t});\n\n\t\t\t// Make `a` tags act like a link\n\t\t\tif (tag.toLowerCase() === 'a') {\n\t\t\t\tbutton.attr('href', '#');\n\t\t\t}\n\n\t\t\t// Button tags should have `type=button` so they don't have any default behaviour\n\t\t\tif (tag.toLowerCase() === 'button') {\n\t\t\t\tbutton.attr('type', 'button');\n\t\t\t}\n\n\t\t\tif (dom.liner.tag) {\n\t\t\t\tvar liner = $('<' + dom.liner.tag + '/>')\n\t\t\t\t\t.html(text(config.text))\n\t\t\t\t\t.addClass(dom.liner.className);\n\n\t\t\t\tif (dom.liner.tag.toLowerCase() === 'a') {\n\t\t\t\t\tliner.attr('href', '#');\n\t\t\t\t}\n\n\t\t\t\tbutton.append(liner);\n\t\t\t\ttextNode = liner;\n\t\t\t}\n\t\t\telse {\n\t\t\t\tbutton.html(text(config.text));\n\t\t\t\ttextNode = button;\n\t\t\t}\n\n\t\t\tif (config.enabled === false) {\n\t\t\t\tbutton.addClass(dom.disabled);\n\t\t\t}\n\n\t\t\tif (config.className) {\n\t\t\t\tbutton.addClass(config.className);\n\t\t\t}\n\n\t\t\tif (config.titleAttr) {\n\t\t\t\tbutton.attr('title', text(config.titleAttr));\n\t\t\t}\n\n\t\t\tif (config.attr) {\n\t\t\t\tbutton.attr(config.attr);\n\t\t\t}\n\n\t\t\tif (!config.namespace) {\n\t\t\t\tconfig.namespace = '.dt-button-' + _buttonCounter++;\n\t\t\t}\n\n\t\t\tif (config.config !== undefined && config.config.split) {\n\t\t\t\tconfig.split = config.config.split;\n\t\t\t}\n\t\t}\n\t\telse {\n\t\t\tbutton = $(config.html);\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\t// Style integration callback for DOM manipulation\n\t\t// Note that this is _not_ documented. It is currently\n\t\t// for style integration only\n\t\tif (this.c.buttonCreated) {\n\t\t\tinserter = this.c.buttonCreated(config, inserter);\n\t\t}\n\n\t\tvar splitDiv;\n\n\t\tif (isSplit) {\n\t\t\tvar dropdownConf = inCollection\n\t\t\t\t? $.extend(true, this.c.dom.split, this.c.dom.collection.split)\n\t\t\t\t: this.c.dom.split;\n\t\t\tvar wrapperConf = dropdownConf.wrapper;\n\n\t\t\tsplitDiv = $('<' + wrapperConf.tag + '/>')\n\t\t\t\t.addClass(wrapperConf.className)\n\t\t\t\t.append(button);\n\n\t\t\tvar dropButtonConfig = $.extend(config, {\n\t\t\t\talign: dropdownConf.dropdown.align,\n\t\t\t\tattr: {\n\t\t\t\t\t'aria-haspopup': 'dialog',\n\t\t\t\t\t'aria-expanded': false\n\t\t\t\t},\n\t\t\t\tclassName: dropdownConf.dropdown.className,\n\t\t\t\tcloseButton: false,\n\t\t\t\tsplitAlignClass: dropdownConf.dropdown.splitAlignClass,\n\t\t\t\ttext: dropdownConf.dropdown.text\n\t\t\t});\n\n\t\t\tthis._addKey(dropButtonConfig);\n\n\t\t\tvar splitAction = function (e, dt, button, config) {\n\t\t\t\t_dtButtons.split.action.call(dt.button(splitDiv), e, dt, button, config);\n\n\t\t\t\t$(dt.table().node()).triggerHandler('buttons-action.dt', [\n\t\t\t\t\tdt.button(button),\n\t\t\t\t\tdt,\n\t\t\t\t\tbutton,\n\t\t\t\t\tconfig\n\t\t\t\t]);\n\t\t\t\tbutton.attr('aria-expanded', true);\n\t\t\t};\n\n\t\t\tvar dropButton = $(\n\t\t\t\t'<button class=\"' + dropdownConf.dropdown.className + ' dt-button\"></button>'\n\t\t\t)\n\t\t\t\t.html(dropdownConf.dropdown.dropHtml)\n\t\t\t\t.on('click.dtb', function (e) {\n\t\t\t\t\te.preventDefault();\n\t\t\t\t\te.stopPropagation();\n\n\t\t\t\t\tif (!dropButton.hasClass(dom.disabled)) {\n\t\t\t\t\t\tsplitAction(e, dt, dropButton, dropButtonConfig);\n\t\t\t\t\t}\n\t\t\t\t\tif (clickBlurs) {\n\t\t\t\t\t\tdropButton.trigger('blur');\n\t\t\t\t\t}\n\t\t\t\t})\n\t\t\t\t.on('keypress.dtb', function (e) {\n\t\t\t\t\tif (e.keyCode === 13) {\n\t\t\t\t\t\te.preventDefault();\n\n\t\t\t\t\t\tif (!dropButton.hasClass(dom.disabled)) {\n\t\t\t\t\t\t\tsplitAction(e, dt, dropButton, dropButtonConfig);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t});\n\n\t\t\tif (config.split.length === 0) {\n\t\t\t\tdropButton.addClass('dtb-hide-drop');\n\t\t\t}\n\n\t\t\tsplitDiv.append(dropButton).attr(dropButtonConfig.attr);\n\t\t}\n\n\t\treturn {\n\t\t\tconf: config,\n\t\t\tnode: isSplit ? splitDiv.get(0) : button.get(0),\n\t\t\tinserter: isSplit ? splitDiv : inserter,\n\t\t\tbuttons: [],\n\t\t\tinCollection: inCollection,\n\t\t\tisSplit: isSplit,\n\t\t\tinSplit: inSplit,\n\t\t\tcollection: null,\n\t\t\ttextNode: textNode\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\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\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\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\tif (conf.key) {\n\t\t\tvar character = $.isPlainObject(conf.key) ? conf.key.key : conf.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\tvar that = this;\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) && !Array.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.call(that, 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\treturn { html: 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 Array.isArray(base) ? base : $.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 (Array.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\tif (conf.config !== undefined && objArray.config !== undefined) {\n\t\t\t\tconf.config = $.extend({}, objArray.config, conf.config);\n\t\t\t}\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// 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\t// Buttons to be added to a collection  -gives the ability to define\n\t\t// if buttons should be added to the start or end of a collection\n\t\tvar postfixButtons = conf.postfixButtons;\n\t\tif (postfixButtons) {\n\t\t\tif (!conf.buttons) {\n\t\t\t\tconf.buttons = [];\n\t\t\t}\n\n\t\t\tfor (i = 0, ien = postfixButtons.length; i < ien; i++) {\n\t\t\t\tconf.buttons.push(postfixButtons[i]);\n\t\t\t}\n\t\t}\n\n\t\tvar prefixButtons = conf.prefixButtons;\n\t\tif (prefixButtons) {\n\t\t\tif (!conf.buttons) {\n\t\t\t\tconf.buttons = [];\n\t\t\t}\n\n\t\t\tfor (i = 0, ien = prefixButtons.length; i < ien; i++) {\n\t\t\t\tconf.buttons.splice(i, 0, prefixButtons[i]);\n\t\t\t}\n\t\t}\n\n\t\treturn conf;\n\t},\n\n\t/**\n\t * Display (and replace if there is an existing one) a popover attached to a button\n\t * @param {string|node} content Content to show\n\t * @param {DataTable.Api} hostButton DT API instance of the button\n\t * @param {object} inOpts Options (see object below for all options)\n\t */\n\t_popover: function (content, hostButton, inOpts, e) {\n\t\tvar dt = hostButton;\n\t\tvar c = this.c;\n\t\tvar closed = false;\n\t\tvar options = $.extend(\n\t\t\t{\n\t\t\t\talign: 'button-left', // button-right, dt-container, split-left, split-right\n\t\t\t\tautoClose: false,\n\t\t\t\tbackground: true,\n\t\t\t\tbackgroundClassName: 'dt-button-background',\n\t\t\t\tcloseButton: true,\n\t\t\t\tcontainerClassName: c.dom.collection.container.className,\n\t\t\t\tcontentClassName: c.dom.collection.container.content.className,\n\t\t\t\tcollectionLayout: '',\n\t\t\t\tcollectionTitle: '',\n\t\t\t\tdropup: false,\n\t\t\t\tfade: 400,\n\t\t\t\tpopoverTitle: '',\n\t\t\t\trightAlignClassName: 'dt-button-right',\n\t\t\t\ttag: c.dom.collection.container.tag\n\t\t\t},\n\t\t\tinOpts\n\t\t);\n\n\t\tvar containerSelector = options.tag + '.' + options.containerClassName.replace(/ /g, '.');\n\t\tvar hostNode = hostButton.node();\n\n\t\tvar close = function () {\n\t\t\tclosed = true;\n\n\t\t\t_fadeOut($(containerSelector), options.fade, function () {\n\t\t\t\t$(this).detach();\n\t\t\t});\n\n\t\t\t$(dt.buttons('[aria-haspopup=\"dialog\"][aria-expanded=\"true\"]').nodes()).attr(\n\t\t\t\t'aria-expanded',\n\t\t\t\t'false'\n\t\t\t);\n\n\t\t\t$('div.dt-button-background').off('click.dtb-collection');\n\t\t\tButtons.background(false, options.backgroundClassName, options.fade, hostNode);\n\n\t\t\t$(window).off('resize.resize.dtb-collection');\n\t\t\t$('body').off('.dtb-collection');\n\t\t\tdt.off('buttons-action.b-internal');\n\t\t\tdt.off('destroy');\n\t\t};\n\n\t\tif (content === false) {\n\t\t\tclose();\n\t\t\treturn;\n\t\t}\n\n\t\tvar existingExpanded = $(\n\t\t\tdt.buttons('[aria-haspopup=\"dialog\"][aria-expanded=\"true\"]').nodes()\n\t\t);\n\t\tif (existingExpanded.length) {\n\t\t\t// Reuse the current position if the button that was triggered is inside an existing collection\n\t\t\tif (hostNode.closest(containerSelector).length) {\n\t\t\t\thostNode = existingExpanded.eq(0);\n\t\t\t}\n\n\t\t\tclose();\n\t\t}\n\n\t\t// Try to be smart about the layout\n\t\tvar cnt = $('.dt-button', content).length;\n\t\tvar mod = '';\n\n\t\tif (cnt === 3) {\n\t\t\tmod = 'dtb-b3';\n\t\t}\n\t\telse if (cnt === 2) {\n\t\t\tmod = 'dtb-b2';\n\t\t}\n\t\telse if (cnt === 1) {\n\t\t\tmod = 'dtb-b1';\n\t\t}\n\n\t\tvar display = $('<' + options.tag + '/>')\n\t\t\t.addClass(options.containerClassName)\n\t\t\t.addClass(options.collectionLayout)\n\t\t\t.addClass(options.splitAlignClass)\n\t\t\t.addClass(mod)\n\t\t\t.css('display', 'none')\n\t\t\t.attr({\n\t\t\t\t'aria-modal': true,\n\t\t\t\trole: 'dialog'\n\t\t\t});\n\n\t\tcontent = $(content)\n\t\t\t.addClass(options.contentClassName)\n\t\t\t.attr('role', 'menu')\n\t\t\t.appendTo(display);\n\n\t\thostNode.attr('aria-expanded', 'true');\n\n\t\tif (hostNode.parents('body')[0] !== document.body) {\n\t\t\thostNode = document.body.lastChild;\n\t\t}\n\n\t\tif (options.popoverTitle) {\n\t\t\tdisplay.prepend(\n\t\t\t\t'<div class=\"dt-button-collection-title\">' + options.popoverTitle + '</div>'\n\t\t\t);\n\t\t}\n\t\telse if (options.collectionTitle) {\n\t\t\tdisplay.prepend(\n\t\t\t\t'<div class=\"dt-button-collection-title\">' + options.collectionTitle + '</div>'\n\t\t\t);\n\t\t}\n\n\t\tif (options.closeButton) {\n\t\t\tdisplay\n\t\t\t\t.prepend('<div class=\"dtb-popover-close\">&times;</div>')\n\t\t\t\t.addClass('dtb-collection-closeable');\n\t\t}\n\n\t\t_fadeIn(display.insertAfter(hostNode), options.fade);\n\n\t\tvar tableContainer = $(hostButton.table().container());\n\t\tvar position = display.css('position');\n\n\t\tif (options.span === 'container' || options.align === 'dt-container') {\n\t\t\thostNode = hostNode.parent();\n\t\t\tdisplay.css('width', tableContainer.width());\n\t\t}\n\n\t\t// Align the popover relative to the DataTables container\n\t\t// Useful for wide popovers such as SearchPanes\n\t\tif (position === 'absolute') {\n\t\t\t// Align relative to the host button\n\t\t\tvar offsetParent = $(hostNode[0].offsetParent);\n\t\t\tvar buttonPosition = hostNode.position();\n\t\t\tvar buttonOffset = hostNode.offset();\n\t\t\tvar tableSizes = offsetParent.offset();\n\t\t\tvar containerPosition = offsetParent.position();\n\t\t\tvar computed = window.getComputedStyle(offsetParent[0]);\n\n\t\t\ttableSizes.height = offsetParent.outerHeight();\n\t\t\ttableSizes.width = offsetParent.width() + parseFloat(computed.paddingLeft);\n\t\t\ttableSizes.right = tableSizes.left + tableSizes.width;\n\t\t\ttableSizes.bottom = tableSizes.top + tableSizes.height;\n\n\t\t\t// Set the initial position so we can read height / width\n\t\t\tvar top = buttonPosition.top + hostNode.outerHeight();\n\t\t\tvar left = buttonPosition.left;\n\n\t\t\tdisplay.css({\n\t\t\t\ttop: top,\n\t\t\t\tleft: left\n\t\t\t});\n\n\t\t\t// Get the popover position\n\t\t\tcomputed = window.getComputedStyle(display[0]);\n\t\t\tvar popoverSizes = display.offset();\n\n\t\t\tpopoverSizes.height = display.outerHeight();\n\t\t\tpopoverSizes.width = display.outerWidth();\n\t\t\tpopoverSizes.right = popoverSizes.left + popoverSizes.width;\n\t\t\tpopoverSizes.bottom = popoverSizes.top + popoverSizes.height;\n\t\t\tpopoverSizes.marginTop = parseFloat(computed.marginTop);\n\t\t\tpopoverSizes.marginBottom = parseFloat(computed.marginBottom);\n\n\t\t\t// First position per the class requirements - pop up and right align\n\t\t\tif (options.dropup) {\n\t\t\t\ttop =\n\t\t\t\t\tbuttonPosition.top -\n\t\t\t\t\tpopoverSizes.height -\n\t\t\t\t\tpopoverSizes.marginTop -\n\t\t\t\t\tpopoverSizes.marginBottom;\n\t\t\t}\n\n\t\t\tif (options.align === 'button-right' || display.hasClass(options.rightAlignClassName)) {\n\t\t\t\tleft = buttonPosition.left - popoverSizes.width + hostNode.outerWidth();\n\t\t\t}\n\n\t\t\t// Container alignment - make sure it doesn't overflow the table container\n\t\t\tif (options.align === 'dt-container' || options.align === 'container') {\n\t\t\t\tif (left < buttonPosition.left) {\n\t\t\t\t\tleft = -buttonPosition.left;\n\t\t\t\t}\n\n\t\t\t\tif (left + popoverSizes.width > tableSizes.width) {\n\t\t\t\t\tleft = tableSizes.width - popoverSizes.width;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Window adjustment\n\t\t\tif (containerPosition.left + left + popoverSizes.width > $(window).width()) {\n\t\t\t\t// Overflowing the document to the right\n\t\t\t\tleft = $(window).width() - popoverSizes.width - containerPosition.left;\n\t\t\t}\n\n\t\t\tif (buttonOffset.left + left < 0) {\n\t\t\t\t// Off to the left of the document\n\t\t\t\tleft = -buttonOffset.left;\n\t\t\t}\n\n\t\t\tif (\n\t\t\t\tcontainerPosition.top + top + popoverSizes.height >\n\t\t\t\t$(window).height() + $(window).scrollTop()\n\t\t\t) {\n\t\t\t\t// Pop up if otherwise we'd need the user to scroll down\n\t\t\t\ttop =\n\t\t\t\t\tbuttonPosition.top -\n\t\t\t\t\tpopoverSizes.height -\n\t\t\t\t\tpopoverSizes.marginTop -\n\t\t\t\t\tpopoverSizes.marginBottom;\n\t\t\t}\n\n\t\t\tif (containerPosition.top + top < $(window).scrollTop()) {\n\t\t\t\t// Correction for when the top is beyond the top of the page\n\t\t\t\ttop = buttonPosition.top + hostNode.outerHeight();\n\t\t\t}\n\n\t\t\t// Calculations all done - now set it\n\t\t\tdisplay.css({\n\t\t\t\ttop: top,\n\t\t\t\tleft: left\n\t\t\t});\n\t\t}\n\t\telse {\n\t\t\t// Fix position - centre on screen\n\t\t\tvar position = function () {\n\t\t\t\tvar half = $(window).height() / 2;\n\n\t\t\t\tvar top = display.height() / 2;\n\t\t\t\tif (top > half) {\n\t\t\t\t\ttop = half;\n\t\t\t\t}\n\n\t\t\t\tdisplay.css('marginTop', top * -1);\n\t\t\t};\n\n\t\t\tposition();\n\n\t\t\t$(window).on('resize.dtb-collection', function () {\n\t\t\t\tposition();\n\t\t\t});\n\t\t}\n\n\t\tif (options.background) {\n\t\t\tButtons.background(\n\t\t\t\ttrue,\n\t\t\t\toptions.backgroundClassName,\n\t\t\t\toptions.fade,\n\t\t\t\toptions.backgroundHost || hostNode\n\t\t\t);\n\t\t}\n\n\t\t// This is bonkers, but if we don't have a click listener on the\n\t\t// background element, iOS Safari will ignore the body click\n\t\t// listener below. An empty function here is all that is\n\t\t// required to make it work...\n\t\t$('div.dt-button-background').on('click.dtb-collection', function () {});\n\n\t\tif (options.autoClose) {\n\t\t\tsetTimeout(function () {\n\t\t\t\tdt.on('buttons-action.b-internal', function (e, btn, dt, node) {\n\t\t\t\t\tif (node[0] === hostNode[0]) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tclose();\n\t\t\t\t});\n\t\t\t}, 0);\n\t\t}\n\n\t\t$(display).trigger('buttons-popover.dt');\n\n\t\tdt.on('destroy', close);\n\n\t\tsetTimeout(function () {\n\t\t\tclosed = false;\n\t\t\t$('body')\n\t\t\t\t.on('click.dtb-collection', function (e) {\n\t\t\t\t\tif (closed) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\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\t\t\t\t\tvar parent = $(e.target).parent()[0];\n\n\t\t\t\t\tif (\n\t\t\t\t\t\t(!$(e.target).parents()[back]().filter(content).length &&\n\t\t\t\t\t\t\t!$(parent).hasClass('dt-buttons')) ||\n\t\t\t\t\t\t$(e.target).hasClass('dt-button-background')\n\t\t\t\t\t) {\n\t\t\t\t\t\tclose();\n\t\t\t\t\t}\n\t\t\t\t})\n\t\t\t\t.on('keyup.dtb-collection', function (e) {\n\t\t\t\t\tif (e.keyCode === 27) {\n\t\t\t\t\t\tclose();\n\t\t\t\t\t}\n\t\t\t\t})\n\t\t\t\t.on('keydown.dtb-collection', function (e) {\n\t\t\t\t\t// Focus trap for tab key\n\t\t\t\t\tvar elements = $('a, button', content);\n\t\t\t\t\tvar active = document.activeElement;\n\n\t\t\t\t\tif (e.keyCode !== 9) {\n\t\t\t\t\t\t// tab\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\n\t\t\t\t\tif (elements.index(active) === -1) {\n\t\t\t\t\t\t// If current focus is not inside the popover\n\t\t\t\t\t\telements.first().focus();\n\t\t\t\t\t\te.preventDefault();\n\t\t\t\t\t}\n\t\t\t\t\telse if (e.shiftKey) {\n\t\t\t\t\t\t// Reverse tabbing order when shift key is pressed\n\t\t\t\t\t\tif (active === elements[0]) {\n\t\t\t\t\t\t\telements.last().focus();\n\t\t\t\t\t\t\te.preventDefault();\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\tif (active === elements.last()[0]) {\n\t\t\t\t\t\t\telements.first().focus();\n\t\t\t\t\t\t\te.preventDefault();\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t}, 0);\n\t}\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, insertPoint) {\n\tif (fade === undefined) {\n\t\tfade = 400;\n\t}\n\tif (!insertPoint) {\n\t\tinsertPoint = document.body;\n\t}\n\n\tif (show) {\n\t\t_fadeIn(\n\t\t\t$('<div/>').addClass(className).css('display', 'none').insertAfter(insertPoint),\n\t\t\tfade\n\t\t);\n\t}\n\telse {\n\t\t_fadeOut($('div.' + className), fade, function () {\n\t\t\t$(this).removeClass(className).remove();\n\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\tif (group === undefined || group === null) {\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 (Array.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(input.trim(), 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\telse if (typeof input === 'object') {\n\t\t\t// Actual instance selector\n\t\t\tret.push(input);\n\t\t}\n\t};\n\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\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 ? baseIdx + i : i + '';\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 (Array.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\tif (inst.s.buttons[selector]) {\n\t\t\t\tret.push({\n\t\t\t\t\tinst: inst,\n\t\t\t\t\tnode: inst.s.buttons[selector].node\n\t\t\t\t});\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(a[i].trim(), 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)\n\t\t\t\t\t.filter(selector)\n\t\t\t\t\t.each(function () {\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: this\n\t\t\t\t\t\t});\n\t\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\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 * Default function used for formatting output data.\n * @param {*} str Data to strip\n */\nButtons.stripData = function (str, config) {\n\tif (typeof str !== 'string') {\n\t\treturn str;\n\t}\n\n\t// Always remove script tags\n\tstr = str.replace(/<script\\b[^<]*(?:(?!<\\/script>)<[^<]*)*<\\/script>/gi, '');\n\n\t// Always remove comments\n\tstr = str.replace(/<!\\-\\-.*?\\-\\->/g, '');\n\n\tif (!config || config.stripHtml) {\n\t\tstr = str.replace(/<[^>]*>/g, '');\n\t}\n\n\tif (!config || config.trim) {\n\t\tstr = str.replace(/^\\s+|\\s+$/g, '');\n\t}\n\n\tif (!config || config.stripNewlines) {\n\t\tstr = str.replace(/\\n/g, ' ');\n\t}\n\n\tif (!config || config.decodeEntities) {\n\t\t_exportTextarea.innerHTML = str;\n\t\tstr = _exportTextarea.value;\n\t}\n\n\treturn str;\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\taction: {\n\t\t\t\t// action button\n\t\t\t\tdropHtml: '<span class=\"dt-button-down-arrow\">&#x25BC;</span>'\n\t\t\t},\n\t\t\tcontainer: {\n\t\t\t\t// The element used for the dropdown\n\t\t\t\tclassName: 'dt-button-collection',\n\t\t\t\tcontent: {\n\t\t\t\t\tclassName: '',\n\t\t\t\t\ttag: 'div'\n\t\t\t\t},\n\t\t\t\ttag: 'div'\n\t\t\t}\n\t\t\t// optionally\n\t\t\t// , button: IButton - buttons inside the collection container\n\t\t\t// , split: ISplit - splits inside the collection container\n\t\t},\n\t\tbutton: {\n\t\t\ttag: 'button',\n\t\t\tclassName: 'dt-button',\n\t\t\tactive: 'dt-button-active', // class name\n\t\t\tdisabled: 'disabled', // class name\n\t\t\tspacer: {\n\t\t\t\tclassName: 'dt-button-spacer',\n\t\t\t\ttag: 'span'\n\t\t\t},\n\t\t\tliner: {\n\t\t\t\ttag: 'span',\n\t\t\t\tclassName: ''\n\t\t\t}\n\t\t},\n\t\tsplit: {\n\t\t\taction: {\n\t\t\t\t// action button\n\t\t\t\tclassName: 'dt-button-split-drop-button dt-button',\n\t\t\t\ttag: 'button'\n\t\t\t},\n\t\t\tdropdown: {\n\t\t\t\t// button to trigger the dropdown\n\t\t\t\talign: 'split-right',\n\t\t\t\tclassName: 'dt-button-split-drop',\n\t\t\t\tdropHtml: '<span class=\"dt-button-down-arrow\">&#x25BC;</span>',\n\t\t\t\tsplitAlignClass: 'dt-button-split-left',\n\t\t\t\ttag: 'button'\n\t\t\t},\n\t\t\twrapper: {\n\t\t\t\t// wrap around both\n\t\t\t\tclassName: 'dt-button-split',\n\t\t\t\ttag: 'div'\n\t\t\t}\n\t\t}\n\t}\n};\n\n/**\n * Version information\n * @type {string}\n * @static\n */\nButtons.version = '2.4.1';\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\tcloseButton: false,\n\t\tinit: function (dt, button, config) {\n\t\t\tbutton.attr('aria-expanded', false);\n\t\t},\n\t\taction: function (e, dt, button, config) {\n\t\t\tif (config._collection.parents('body').length) {\n\t\t\t\tthis.popover(false, config);\n\t\t\t}\n\t\t\telse {\n\t\t\t\tthis.popover(config._collection, config);\n\t\t\t}\n\n\t\t\t// When activated using a key - auto focus on the\n\t\t\t// first item in the popover\n\t\t\tif (e.type === 'keypress') {\n\t\t\t\t$('a, button', config._collection).eq(0).focus();\n\t\t\t}\n\t\t},\n\t\tattr: {\n\t\t\t'aria-haspopup': 'dialog'\n\t\t}\n\t\t// Also the popover options, defined in Buttons.popover\n\t},\n\tsplit: {\n\t\ttext: function (dt) {\n\t\t\treturn dt.i18n('buttons.split', 'Split');\n\t\t},\n\t\tclassName: 'buttons-split',\n\t\tcloseButton: false,\n\t\tinit: function (dt, button, config) {\n\t\t\treturn button.attr('aria-expanded', false);\n\t\t},\n\t\taction: function (e, dt, button, config) {\n\t\t\tthis.popover(config._collection, config);\n\t\t},\n\t\tattr: {\n\t\t\t'aria-haspopup': 'dialog'\n\t\t}\n\t\t// Also the popover options, defined in Buttons.popover\n\t},\n\tcopy: function (dt, conf) {\n\t\tif (_dtButtons.copyHtml5) {\n\t\t\treturn 'copyHtml5';\n\t\t}\n\t},\n\tcsv: function (dt, conf) {\n\t\tif (_dtButtons.csvHtml5 && _dtButtons.csvHtml5.available(dt, conf)) {\n\t\t\treturn 'csvHtml5';\n\t\t}\n\t},\n\texcel: function (dt, conf) {\n\t\tif (_dtButtons.excelHtml5 && _dtButtons.excelHtml5.available(dt, conf)) {\n\t\t\treturn 'excelHtml5';\n\t\t}\n\t},\n\tpdf: function (dt, conf) {\n\t\tif (_dtButtons.pdfHtml5 && _dtButtons.pdfHtml5.available(dt, conf)) {\n\t\t\treturn 'pdfHtml5';\n\t\t}\n\t},\n\tpageLength: function (dt) {\n\t\tvar lengthMenu = dt.settings()[0].aLengthMenu;\n\t\tvar vals = [];\n\t\tvar lang = [];\n\t\tvar text = function (dt) {\n\t\t\treturn dt.i18n(\n\t\t\t\t'buttons.pageLength',\n\t\t\t\t{\n\t\t\t\t\t'-1': 'Show all rows',\n\t\t\t\t\t_: 'Show %d rows'\n\t\t\t\t},\n\t\t\t\tdt.page.len()\n\t\t\t);\n\t\t};\n\n\t\t// Support for DataTables 1.x 2D array\n\t\tif (Array.isArray(lengthMenu[0])) {\n\t\t\tvals = lengthMenu[0];\n\t\t\tlang = lengthMenu[1];\n\t\t}\n\t\telse {\n\t\t\tfor (var i = 0; i < lengthMenu.length; i++) {\n\t\t\t\tvar option = lengthMenu[i];\n\n\t\t\t\t// Support for DataTables 2 object in the array\n\t\t\t\tif ($.isPlainObject(option)) {\n\t\t\t\t\tvals.push(option.value);\n\t\t\t\t\tlang.push(option.label);\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tvals.push(option);\n\t\t\t\t\tlang.push(option);\n\t\t\t\t}\n\t\t\t}\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(conf.text);\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\tspacer: {\n\t\tstyle: 'empty',\n\t\tspacer: true,\n\t\ttext: function (dt) {\n\t\t\treturn dt.i18n('buttons.spacer', '');\n\t\t}\n\t}\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(\n\t\ttrue,\n\t\t'table',\n\t\tfunction (ctx) {\n\t\t\tif (ctx._buttons) {\n\t\t\t\treturn Buttons.buttonSelector(\n\t\t\t\t\tButtons.instanceSelector(group, ctx._buttons),\n\t\t\t\t\tselector\n\t\t\t\t);\n\t\t\t}\n\t\t},\n\t\ttrue\n\t);\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// Collection control\nDataTable.Api.registerPlural(\n\t'buttons().collectionRebuild()',\n\t'button().collectionRebuild()',\n\tfunction (buttons) {\n\t\treturn this.each(function (set) {\n\t\t\tfor (var i = 0; i < buttons.length; i++) {\n\t\t\t\tif (typeof buttons[i] === 'object') {\n\t\t\t\t\tbuttons[i].parentConf = set;\n\t\t\t\t}\n\t\t\t}\n\t\t\tset.inst.collectionRebuild(set.node, buttons);\n\t\t});\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// Button index\nDataTable.Api.register('button().index()', function () {\n\tvar idx = null;\n\n\tthis.each(function (set) {\n\t\tvar res = set.inst.index(set.node);\n\n\t\tif (res !== null) {\n\t\t\tidx = res;\n\t\t}\n\t});\n\n\treturn idx;\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$(\n\t\tthis.each(function (set) {\n\t\t\tjq = jq.add(set.inst.node(set.node));\n\t\t})\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// Button resolver to the popover\nDataTable.Api.register('button().popover()', function (content, options) {\n\treturn this.map(function (set) {\n\t\treturn set.inst._popover(content, this.button(this[0].node), options);\n\t});\n});\n\n// Get the container elements\nDataTable.Api.register('buttons().containers()', 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\nDataTable.Api.register('buttons().container()', function () {\n\t// API level of nesting is `buttons()` so we can zip into the containers method\n\treturn this.containers().eq(0);\n});\n\n// Add a new button\nDataTable.Api.register('button().add()', function (idx, conf, draw) {\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, draw);\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')\n\t\t.unique()\n\t\t.each(function (inst) {\n\t\t\tinst.destroy();\n\t\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\tthis.off('destroy.btn-info');\n\t\t_fadeOut($('#datatables_buttons_info'), 400, 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_fadeIn(\n\t\t$('<div id=\"datatables_buttons_info\" class=\"dt-button-info\"/>')\n\t\t\t.html(title)\n\t\t\t.append($('<div/>')[typeof message === 'string' ? 'html' : 'append'](message))\n\t\t\t.css('display', 'none')\n\t\t\t.appendTo('body')\n\t);\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\tthis.on('destroy.btn-info', function () {\n\t\tthat.buttons.info(false);\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 * 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\t// Backwards compatibility\n\tvar filename =\n\t\tconfig.filename === '*' &&\n\t\tconfig.title !== '*' &&\n\t\tconfig.title !== undefined &&\n\t\tconfig.title !== null &&\n\t\tconfig.title !== ''\n\t\t\t? config.title\n\t\t\t: config.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 = filename.replace('*', $('head > title').text()).trim();\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\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\tvar title = _stringOrFunction(config.title);\n\n\treturn title === null\n\t\t? null\n\t\t: title.indexOf('*') !== -1\n\t\t? title.replace('*', $('head > title').text() || 'Exported data')\n\t\t: title;\n};\n\nvar _message = function (dt, option, position) {\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 ? caption.text() : '';\n\t}\n\n\treturn message;\n};\n\nvar _exportTextarea = $('<textarea/>')[0];\nvar _exportData = function (dt, inOpts) {\n\tvar config = $.extend(\n\t\ttrue,\n\t\t{},\n\t\t{\n\t\t\trows: null,\n\t\t\tcolumns: '',\n\t\t\tmodifier: {\n\t\t\t\tsearch: 'applied',\n\t\t\t\torder: 'applied'\n\t\t\t},\n\t\t\torthogonal: 'display',\n\t\t\tstripHtml: true,\n\t\t\tstripNewlines: true,\n\t\t\tdecodeEntities: true,\n\t\t\ttrim: true,\n\t\t\tformat: {\n\t\t\t\theader: function (d) {\n\t\t\t\t\treturn Buttons.stripData(d, config);\n\t\t\t\t},\n\t\t\t\tfooter: function (d) {\n\t\t\t\t\treturn Buttons.stripData(d, config);\n\t\t\t\t},\n\t\t\t\tbody: function (d) {\n\t\t\t\t\treturn Buttons.stripData(d, config);\n\t\t\t\t}\n\t\t\t},\n\t\t\tcustomizeData: null\n\t\t},\n\t\tinOpts\n\t);\n\n\tvar header = dt\n\t\t.columns(config.columns)\n\t\t.indexes()\n\t\t.map(function (idx) {\n\t\t\tvar el = dt.column(idx).header();\n\t\t\treturn config.format.header(el.innerHTML, idx, el);\n\t\t})\n\t\t.toArray();\n\n\tvar footer = dt.table().footer()\n\t\t? dt\n\t\t\t\t.columns(config.columns)\n\t\t\t\t.indexes()\n\t\t\t\t.map(function (idx) {\n\t\t\t\t\tvar el = dt.column(idx).footer();\n\t\t\t\t\treturn config.format.footer(el ? el.innerHTML : '', idx, el);\n\t\t\t\t})\n\t\t\t\t.toArray()\n\t\t: null;\n\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.render(config.orthogonal).toArray();\n\tvar cellNodes = selectedCells.nodes().toArray();\n\n\tvar columns = header.length;\n\tvar rows = columns > 0 ? cells.length / columns : 0;\n\tvar body = [];\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\tvar data = {\n\t\theader: header,\n\t\tfooter: footer,\n\t\tbody: body\n\t};\n\n\tif (config.customizeData) {\n\t\tconfig.customizeData(data);\n\t}\n\n\treturn data;\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// 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\nfunction _init(settings, options) {\n\tvar api = new DataTable.Api(settings);\n\tvar opts = options ? options : api.init().buttons || DataTable.defaults.buttons;\n\n\treturn new Buttons(api, opts).container();\n}\n\n// DataTables `dom` feature option\nDataTable.ext.feature.push({\n\tfnInit: _init,\n\tcFeature: 'B'\n});\n\n// DataTables 2 layout feature\nif (DataTable.ext.features) {\n\tDataTable.ext.features.register('buttons', _init);\n}\n\n\nexport default DataTable;\n","/*! Bootstrap 5 integration for DataTables' Responsive\n * © SpryMedia Ltd - datatables.net/license\n */\n\nimport jQuery from 'jquery';\nimport DataTable from 'datatables.net-bs5';\nimport Responsive from 'datatables.net-responsive';\n\n// Allow reassignment of the $ variable\nlet $ = jQuery;\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'<div class=\"modal-content\">' +\n\t\t'<div class=\"modal-header\">' +\n\t\t'<button type=\"button\" class=\"btn-close\" data-bs-dismiss=\"modal\" aria-label=\"Close\"></button>' +\n\t\t'</div>' +\n\t\t'<div class=\"modal-body\"/>' +\n\t\t'</div>' +\n\t\t'</div>' +\n\t\t'</div>'\n);\nvar modal;\n\n// Note this could be undefined at the time of initialisation - the\n// DataTable.Responsive.bootstrap function can be used to set a different\n// bootstrap object\nvar _bs = window.bootstrap;\n\nDataTable.Responsive.bootstrap = function (bs) {\n\t_bs = bs;\n};\n\n_display.modal = function (options) {\n\tif (!modal) {\n\t\tmodal = new _bs.Modal(_modal[0]);\n\t}\n\n\treturn function (row, update, render, closeCallback) {\n\t\tif (!$.fn.modal) {\n\t\t\treturn _original(row, update, render, closeCallback);\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\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.append(button);\n\t\t\t\t}\n\n\t\t\t\t_modal.find('div.modal-body').empty().append(render());\n\n\t\t\t\t_modal\n\t\t\t\t\t.data('dtr-row-idx', row.index())\n\t\t\t\t\t.one('hidden.bs.modal', closeCallback)\n\t\t\t\t\t.appendTo('body')\n\t\t\t\t\t.modal();\n\n\t\t\t\tmodal.show();\n\t\t\t}\n\t\t\telse {\n\t\t\t\tif ($.contains(document, _modal[0]) && row.index() === _modal.data('dtr-row-idx')) {\n\t\t\t\t\t_modal.find('div.modal-body').empty().append(render());\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\t// Modal not shown for this row - do nothing\n\t\t\t\t\treturn null;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn true;\n\t\t}\n\t};\n};\n\n\nexport default DataTable;\n","/*! Responsive 2.5.0\n * © SpryMedia Ltd - datatables.net/license\n */\n\nimport jQuery from 'jquery';\nimport DataTable from 'datatables.net';\n\n// Allow reassignment of the $ variable\nlet $ = jQuery;\n\n\n/**\n * @summary     Responsive\n * @description Responsive tables plug-in for DataTables\n * @version     2.5.0\n * @author      SpryMedia Ltd\n * @copyright   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\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\tchildNodeStore: {},\n\t\tcolumns: [],\n\t\tcurrent: [],\n\t\tdt: new DataTable.Api(settings)\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\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(\n\t\t\t'resize.dtr orientationchange.dtr',\n\t\t\tDataTable.util.throttle(function () {\n\t\t\t\t// iOS has a bug whereby resize can fire when only scrolling\n\t\t\t\t// See: http://stackoverflow.com/questions/8898412\n\t\t\t\tvar width = $(window).innerWidth();\n\n\t\t\t\tif (width !== oldWindowWidth) {\n\t\t\t\t\tthat._resize();\n\t\t\t\t\toldWindowWidth = width;\n\t\t\t\t}\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(\n\t\t\tdtPrivateSettings,\n\t\t\t'aoRowCreatedCallback',\n\t\t\tfunction (tr, data, idx) {\n\t\t\t\tif ($.inArray(false, that.s.current) !== -1) {\n\t\t\t\t\t$('>td, >th', tr).each(function (i) {\n\t\t\t\t\t\tvar idx = dt.column.index('toData', i);\n\n\t\t\t\t\t\tif (that.s.current[idx] === false) {\n\t\t\t\t\t\t\t$(this).css('display', 'none');\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\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 : a.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// DT2 let's us tell it if we are hiding columns\n\t\tdt.on('column-calc.dt', function (e, d) {\n\t\t\tvar curr = that.s.current;\n\n\t\t\tfor (var i = 0; i < curr.length; i++) {\n\t\t\t\tvar idx = d.visible.indexOf(i);\n\n\t\t\t\tif (curr[i] === false && idx >= 0) {\n\t\t\t\t\td.visible.splice(idx, 1);\n\t\t\t\t}\n\t\t\t}\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.on('draw.dtr', function () {\n\t\t\tthat._controlClass();\n\t\t}).on('init.dtr', function (e, settings, details) {\n\t\t\tif (e.namespace !== 'dt') {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tthat._resizeAuto();\n\t\t\tthat._resize();\n\n\t\t\t// If columns were hidden, then DataTables needs to adjust the\n\t\t\t// column sizing\n\t\t\tif ($.inArray(false, that.s.current)) {\n\t\t\t\tdt.columns.adjust();\n\t\t\t}\n\t\t});\n\n\t\t// First pass - draw the table for the current viewport size\n\t\tthis._resize();\n\t},\n\n\t/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n\t * Private methods\n\t */\n\n\t/**\n\t * Get and store nodes from a cell - use for node moving renderers\n\t *\n\t * @param {*} dt DT instance\n\t * @param {*} row Row index\n\t * @param {*} col Column index\n\t */\n\t_childNodes: function (dt, row, col) {\n\t\tvar name = row + '-' + col;\n\n\t\tif (this.s.childNodeStore[name]) {\n\t\t\treturn this.s.childNodeStore[name];\n\t\t}\n\n\t\t// https://jsperf.com/childnodes-array-slice-vs-loop\n\t\tvar nodes = [];\n\t\tvar children = dt.cell(row, col).node().childNodes;\n\t\tfor (var i = 0, ien = children.length; i < ien; i++) {\n\t\t\tnodes.push(children[i]);\n\t\t}\n\n\t\tthis.s.childNodeStore[name] = nodes;\n\n\t\treturn nodes;\n\t},\n\n\t/**\n\t * Restore nodes from the cache to a table cell\n\t *\n\t * @param {*} dt DT instance\n\t * @param {*} row Row index\n\t * @param {*} col Column index\n\t */\n\t_childNodesRestore: function (dt, row, col) {\n\t\tvar name = row + '-' + col;\n\n\t\tif (!this.s.childNodeStore[name]) {\n\t\t\treturn;\n\t\t}\n\n\t\tvar node = dt.cell(row, col).node();\n\t\tvar store = this.s.childNodeStore[name];\n\t\tvar parent = store[0].parentNode;\n\t\tvar parentChildren = parent.childNodes;\n\t\tvar a = [];\n\n\t\tfor (var i = 0, ien = parentChildren.length; i < ien; i++) {\n\t\t\ta.push(parentChildren[i]);\n\t\t}\n\n\t\tfor (var j = 0, jen = a.length; j < jen; j++) {\n\t\t\tnode.appendChild(a[j]);\n\t\t}\n\n\t\tthis.s.childNodeStore[name] = undefined;\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\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\t? false\n\t\t\t\t: col.auto === true\n\t\t\t\t? '-'\n\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\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\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\n\t\t\t.columns()\n\t\t\t.eq(0)\n\t\t\t.map(function (i) {\n\t\t\t\tvar column = this.column(i);\n\t\t\t\tvar className = column.header().className;\n\t\t\t\tvar priority = dt.settings()[0].aoColumns[i].responsivePriority;\n\t\t\t\tvar dataPriority = column.header().getAttribute('data-priority');\n\n\t\t\t\tif (priority === undefined) {\n\t\t\t\t\tpriority =\n\t\t\t\t\t\tdataPriority === undefined || dataPriority === null\n\t\t\t\t\t\t\t? 10000\n\t\t\t\t\t\t\t: dataPriority * 1;\n\t\t\t\t}\n\n\t\t\t\treturn {\n\t\t\t\t\tclassName: className,\n\t\t\t\t\tincludeIn: [],\n\t\t\t\t\tauto: false,\n\t\t\t\t\tcontrol: false,\n\t\t\t\t\tnever: className.match(/\\b(dtr\\-)?never\\b/) ? true : false,\n\t\t\t\t\tpriority: priority\n\t\t\t\t};\n\t\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' || className === 'dtr-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' || className === 'dtr-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(\n\t\t\t\t\t\t'(min\\\\-|max\\\\-|not\\\\-)?(' + brokenPoint[0] + ')(\\\\-[_a-zA-Z0-9])?'\n\t\t\t\t\t);\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\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' }).nodes().to$().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\tvar that = this;\n\t\tvar dt = this.s.dt;\n\t\tvar details = this.c.details;\n\t\tvar event = function (res) {\n\t\t\t$(row.node()).toggleClass('parent', res !== false);\n\t\t\t$(dt.table().node()).triggerHandler('responsive-display.dt', [dt, row, res, update]);\n\t\t};\n\n\t\tif (details && details.type !== false) {\n\t\t\tvar renderer =\n\t\t\t\ttypeof details.renderer === 'string'\n\t\t\t\t\t? Responsive.renderer[details.renderer]()\n\t\t\t\t\t: details.renderer;\n\n\t\t\tvar res = details.display(\n\t\t\t\trow,\n\t\t\t\tupdate,\n\t\t\t\tfunction () {\n\t\t\t\t\treturn renderer.call(that, dt, row[0], that._detailsObj(row[0]));\n\t\t\t\t},\n\t\t\t\tfunction () {\n\t\t\t\t\tevent(false);\n\t\t\t\t}\n\t\t\t);\n\n\t\t\tif (typeof res === 'boolean') {\n\t\t\t\tevent(res);\n\t\t\t}\n\t\t}\n\t},\n\n\t/**\n\t * Initialisation for the details handler\n\t *\n\t * @private\n\t */\n\t_detailsInit: function () {\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()).on('click.dtr mousedown.dtr mouseup.dtr', selector, function (e) {\n\t\t\t\t// If the table is not collapsed (i.e. there is no hidden columns)\n\t\t\t\t// then take no action\n\t\t\t\tif (!$(dt.table().node()).hasClass('collapsed')) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\t// Check that the row is actually a DataTable's controlled node\n\t\t\t\tif ($.inArray($(this).closest('tr').get(0), dt.rows().nodes().toArray()) === -1) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\t// For column index, we determine if we should act or not in the\n\t\t\t\t// handler - otherwise it is already okay\n\t\t\t\tif (typeof target === 'number') {\n\t\t\t\t\tvar targetIdx = target < 0 ? dt.columns().eq(0).length + target : target;\n\n\t\t\t\t\tif (dt.cell(this).index().column !== targetIdx) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// $().closest() includes itself in its check\n\t\t\t\tvar row = dt.row($(this).closest('tr'));\n\n\t\t\t\t// Check event type to do an action\n\t\t\t\tif (e.type === 'click') {\n\t\t\t\t\t// The renderer is given as a function so the caller can execute it\n\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// the renderer)\n\t\t\t\t\tthat._detailsDisplay(row, false);\n\t\t\t\t}\n\t\t\t\telse if (e.type === 'mousedown') {\n\t\t\t\t\t// For mouse users, prevent the focus ring from showing\n\t\t\t\t\t$(this).css('outline', 'none');\n\t\t\t\t}\n\t\t\t\telse if (e.type === 'mouseup') {\n\t\t\t\t\t// And then re-allow at the end of the click\n\t\t\t\t\t$(this).trigger('blur').css('outline', '');\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t},\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\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 ? dtCol.sTitle : $(dt.column(i).header()).text()\n\t\t\t};\n\t\t});\n\t},\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\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\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\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\tthat._detailsDisplay(dt.row(idx), true);\n\t\t});\n\t},\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\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\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\n\t\tfor (i = 0, ien = columns.length; i < ien; i++) {\n\t\t\tif (\n\t\t\t\tcolumnsVis[i] === false &&\n\t\t\t\t!columns[i].never &&\n\t\t\t\t!columns[i].control &&\n\t\t\t\t!dt.column(i).visible() === false\n\t\t\t) {\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()\n\t\t\t.eq(0)\n\t\t\t.each(function (colIdx, i) {\n\t\t\t\tif (columnsVis[i] === true) {\n\t\t\t\t\tvisible++;\n\t\t\t\t}\n\n\t\t\t\tif (forceRedraw || columnsVis[i] !== oldVis[i]) {\n\t\t\t\t\tchanged = true;\n\t\t\t\t\tthat._setColumnVis(colIdx, columnsVis[i]);\n\t\t\t\t}\n\t\t\t});\n\n\t\t// Always need to update the display, regardless of if it has changed or not, so nodes\n\t\t// can be re-inserted for listHiddenNodes\n\t\tthis._redrawChildren();\n\n\t\tif (changed) {\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\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\tvar dt = this.s.dt;\n\t\tvar columns = this.s.columns;\n\t\tvar that = this;\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 (\n\t\t\t$.inArray(\n\t\t\t\ttrue,\n\t\t\t\t$.map(columns, function (c) {\n\t\t\t\t\treturn c.auto;\n\t\t\t\t})\n\t\t\t) === -1\n\t\t) {\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(this.s.childNodeStore)) {\n\t\t\t$.each(this.s.childNodeStore, function (key) {\n\t\t\t\tvar idx = key.split('-');\n\n\t\t\t\tthat._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\n\t\t\t.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')\n\t\t\t.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\n\t\t\t\t.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/>').append(footerCells).appendTo(clonedFooter);\n\t\t}\n\n\t\t$('<tr/>').append(headerCells).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\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\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\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\tvar that = this;\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).toggleClass('dtr-hidden', !showHide);\n\n\t\t$(dt.column(col).footer()).css('display', display).toggleClass('dtr-hidden', !showHide);\n\n\t\tdt.column(col).nodes().to$().css('display', display).toggleClass('dtr-hidden', !showHide);\n\n\t\t// If the are child nodes stored, we might need to reinsert them\n\t\tif (!$.isEmptyObject(this.s.childNodeStore)) {\n\t\t\tdt.cells(null, col)\n\t\t\t\t.indexes()\n\t\t\t\t.each(function (idx) {\n\t\t\t\t\tthat._childNodesRestore(dt, idx.row, idx.column);\n\t\t\t\t});\n\t\t}\n\t},\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\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' })\n\t\t\t\t.nodes()\n\t\t\t\t.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 * 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 * 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\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\telse {\n\t\t\t\trow.child(false);\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\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\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, closeCallback) {\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\t$(row.node()).removeClass('parent');\n\n\t\t\t\t\tcloseCallback();\n\t\t\t\t};\n\n\t\t\t\tvar modal = $('<div class=\"dtr-modal\"/>')\n\t\t\t\t\t.append(\n\t\t\t\t\t\t$('<div class=\"dtr-modal-display\"/>')\n\t\t\t\t\t\t\t.append(\n\t\t\t\t\t\t\t\t$('<div class=\"dtr-modal-content\"/>')\n\t\t\t\t\t\t\t\t\t.data('dtr-row-idx', row.index())\n\t\t\t\t\t\t\t\t\t.append(render())\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\t$('<div class=\"dtr-modal-close\">&times;</div>').click(function () {\n\t\t\t\t\t\t\t\t\tclose();\n\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\t\t.append(\n\t\t\t\t\t\t$('<div class=\"dtr-modal-background\"/>').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$(row.node()).addClass('parent');\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\tvar modal = $('div.dtr-modal-content');\n\n\t\t\t\tif (modal.length && row.index() === modal.data('dtr-row-idx')) {\n\t\t\t\t\tmodal.empty().append(render());\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\t// Modal not shown, nothing to update\n\t\t\t\t\treturn null;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (options && options.header) {\n\t\t\t\t$('div.dtr-modal-content').prepend('<h2>' + options.header(row) + '</h2>');\n\t\t\t}\n\n\t\t\treturn true;\n\t\t};\n\t}\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 that = this;\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 ? 'class=\"' + col.className + '\"' : '';\n\n\t\t\t\t\t$(\n\t\t\t\t\t\t'<li ' +\n\t\t\t\t\t\t\tklass +\n\t\t\t\t\t\t\t' data-dtr-index=\"' +\n\t\t\t\t\t\t\tcol.columnIndex +\n\t\t\t\t\t\t\t'\" data-dt-row=\"' +\n\t\t\t\t\t\t\tcol.rowIndex +\n\t\t\t\t\t\t\t'\" data-dt-column=\"' +\n\t\t\t\t\t\t\tcol.columnIndex +\n\t\t\t\t\t\t\t'\">' +\n\t\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\t'</span> ' +\n\t\t\t\t\t\t\t'</li>'\n\t\t\t\t\t)\n\t\t\t\t\t\t.append(\n\t\t\t\t\t\t\t$('<span class=\"dtr-data\"/>').append(\n\t\t\t\t\t\t\t\tthat._childNodes(api, col.rowIndex, col.columnIndex)\n\t\t\t\t\t\t\t)\n\t\t\t\t\t\t) // 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 ? ul : false;\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 ? 'class=\"' + col.className + '\"' : '';\n\n\t\t\t\treturn col.hidden\n\t\t\t\t\t? '<li ' +\n\t\t\t\t\t\t\tklass +\n\t\t\t\t\t\t\t' data-dtr-index=\"' +\n\t\t\t\t\t\t\tcol.columnIndex +\n\t\t\t\t\t\t\t'\" data-dt-row=\"' +\n\t\t\t\t\t\t\tcol.rowIndex +\n\t\t\t\t\t\t\t'\" data-dt-column=\"' +\n\t\t\t\t\t\t\tcol.columnIndex +\n\t\t\t\t\t\t\t'\">' +\n\t\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\t'</span> ' +\n\t\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\t'</span>' +\n\t\t\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\t: false;\n\t\t};\n\t},\n\n\ttableAll: function (options) {\n\t\toptions = $.extend(\n\t\t\t{\n\t\t\t\ttableClass: ''\n\t\t\t},\n\t\t\toptions\n\t\t);\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 ? 'class=\"' + col.className + '\"' : '';\n\n\t\t\t\treturn (\n\t\t\t\t\t'<tr ' +\n\t\t\t\t\tklass +\n\t\t\t\t\t' data-dt-row=\"' +\n\t\t\t\t\tcol.rowIndex +\n\t\t\t\t\t'\" data-dt-column=\"' +\n\t\t\t\t\tcol.columnIndex +\n\t\t\t\t\t'\">' +\n\t\t\t\t\t'<td>' +\n\t\t\t\t\tcol.title +\n\t\t\t\t\t':' +\n\t\t\t\t\t'</td> ' +\n\t\t\t\t\t'<td>' +\n\t\t\t\t\tcol.data +\n\t\t\t\t\t'</td>' +\n\t\t\t\t\t'</tr>'\n\t\t\t\t);\n\t\t\t}).join('');\n\n\t\t\treturn $('<table class=\"' + options.tableClass + ' dtr-details\" width=\"100%\"/>').append(\n\t\t\t\tdata\n\t\t\t);\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 * 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\t: false;\n});\n\nApi.registerPlural('columns().responsiveHidden()', 'column().responsiveHidden()', function () {\n\treturn this.iterator(\n\t\t'column',\n\t\tfunction (settings, column) {\n\t\t\treturn settings._responsive\n\t\t\t\t? settings._responsive._responsiveOnlyHidden()[column]\n\t\t\t\t: false;\n\t\t},\n\t\t1\n\t);\n});\n\n/**\n * Version information\n *\n * @name Responsive.version\n * @static\n */\nResponsive.version = '2.5.0';\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 (\n\t\t$(settings.nTable).hasClass('responsive') ||\n\t\t$(settings.nTable).hasClass('dt-responsive') ||\n\t\tsettings.oInit.responsive ||\n\t\tDataTable.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\nexport default DataTable;\n","/*! Bootstrap 5 styling wrapper for RowGroup\n * © SpryMedia Ltd - datatables.net/license\n */\n\nimport jQuery from 'jquery';\nimport DataTable from 'datatables.net-bs5';\nimport RowGroup from 'datatables.net-rowgroup';\n\n// Allow reassignment of the $ variable\nlet $ = jQuery;\n\n\n\nexport default DataTable;\n","/*! RowGroup 1.4.0\n * © SpryMedia Ltd - datatables.net/license\n */\n\nimport jQuery from 'jquery';\nimport DataTable from 'datatables.net';\n\n// Allow reassignment of the $ variable\nlet $ = jQuery;\n\n\n/**\n * @summary     RowGroup\n * @description RowGrouping for DataTables\n * @version     1.4.0\n * @author      SpryMedia Ltd (www.sprymedia.co.uk)\n * @contact     datatables.net\n * @copyright   SpryMedia Ltd.\n *\n * This source file is free software, available under the following license:\n *   MIT license - http://datatables.net/license/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\nvar RowGroup = function (dt, opts) {\n\t// Sanity check that we are using DataTables 1.10 or newer\n\tif (!DataTable.versionCheck || !DataTable.versionCheck('1.10.8')) {\n\t\tthrow 'RowGroup requires DataTables 1.10.8 or newer';\n\t}\n\n\t// User and defaults configuration object\n\tthis.c = $.extend(true, {}, DataTable.defaults.rowGroup, RowGroup.defaults, opts);\n\n\t// Internal settings\n\tthis.s = {\n\t\tdt: new DataTable.Api(dt)\n\t};\n\n\t// DOM items\n\tthis.dom = {};\n\n\t// Check if row grouping has already been initialised on this table\n\tvar settings = this.s.dt.settings()[0];\n\tvar existing = settings.rowGroup;\n\tif (existing) {\n\t\treturn existing;\n\t}\n\n\tsettings.rowGroup = this;\n\tthis._constructor();\n};\n\n$.extend(RowGroup.prototype, {\n\t/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n\t * API methods for DataTables API interface\n\t */\n\n\t/**\n\t * Get/set the grouping data source - need to call draw after this is\n\t * executed as a setter\n\t * @returns string~RowGroup\n\t */\n\tdataSrc: function (val) {\n\t\tif (val === undefined) {\n\t\t\treturn this.c.dataSrc;\n\t\t}\n\n\t\tvar dt = this.s.dt;\n\n\t\tthis.c.dataSrc = val;\n\n\t\t$(dt.table().node()).triggerHandler('rowgroup-datasrc.dt', [dt, val]);\n\n\t\treturn this;\n\t},\n\n\t/**\n\t * Disable - need to call draw after this is executed\n\t * @returns RowGroup\n\t */\n\tdisable: function () {\n\t\tthis.c.enable = false;\n\t\treturn this;\n\t},\n\n\t/**\n\t * Enable - need to call draw after this is executed\n\t * @returns RowGroup\n\t */\n\tenable: function (flag) {\n\t\tif (flag === false) {\n\t\t\treturn this.disable();\n\t\t}\n\n\t\tthis.c.enable = true;\n\t\treturn this;\n\t},\n\n\t/**\n\t * Get enabled flag\n\t * @returns boolean\n\t */\n\tenabled: function () {\n\t\treturn this.c.enable;\n\t},\n\n\t/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n\t * Constructor\n\t */\n\t_constructor: function () {\n\t\tvar that = this;\n\t\tvar dt = this.s.dt;\n\t\tvar hostSettings = dt.settings()[0];\n\n\t\tdt.on('draw.dtrg', function (e, s) {\n\t\t\tif (that.c.enable && hostSettings === s) {\n\t\t\t\tthat._draw();\n\t\t\t}\n\t\t});\n\n\t\tdt.on('column-visibility.dt.dtrg responsive-resize.dt.dtrg', function () {\n\t\t\tthat._adjustColspan();\n\t\t});\n\n\t\tdt.on('destroy', function () {\n\t\t\tdt.off('.dtrg');\n\t\t});\n\t},\n\n\t/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n\t * Private methods\n\t */\n\n\t/**\n\t * Adjust column span when column visibility changes\n\t * @private\n\t */\n\t_adjustColspan: function () {\n\t\t$('tr.' + this.c.className, this.s.dt.table().body())\n\t\t\t.find('td:visible')\n\t\t\t.attr('colspan', this._colspan());\n\t},\n\n\t/**\n\t * Get the number of columns that a grouping row should span\n\t * @private\n\t */\n\t_colspan: function () {\n\t\treturn this.s.dt\n\t\t\t.columns()\n\t\t\t.visible()\n\t\t\t.reduce(function (a, b) {\n\t\t\t\treturn a + b;\n\t\t\t}, 0);\n\t},\n\n\t/**\n\t * Update function that is called whenever we need to draw the grouping rows.\n\t * This is basically a bootstrap for the self iterative _group and _groupDisplay\n\t * methods\n\t * @private\n\t */\n\t_draw: function () {\n\t\tvar dt = this.s.dt;\n\t\tvar groupedRows = this._group(0, dt.rows({ page: 'current' }).indexes());\n\n\t\tthis._groupDisplay(0, groupedRows);\n\t},\n\n\t/**\n\t * Get the grouping information from a data set (index) of rows\n\t * @param {number} level Nesting level\n\t * @param {DataTables.Api} rows API of the rows to consider for this group\n\t * @returns {object[]} Nested grouping information - it is structured like this:\n\t *\t{\n\t *\t\tdataPoint: 'Edinburgh',\n\t *\t\trows: [ 1,2,3,4,5,6,7 ],\n\t *\t\tchildren: [ {\n\t *\t\t\tdataPoint: 'developer'\n\t *\t\t\trows: [ 1, 2, 3 ]\n\t *\t\t},\n\t *\t\t{\n\t *\t\t\tdataPoint: 'support',\n\t *\t\t\trows: [ 4, 5, 6, 7 ]\n\t *\t\t} ]\n\t *\t}\n\t * @private\n\t */\n\t_group: function (level, rows) {\n\t\tvar fns = Array.isArray(this.c.dataSrc) ? this.c.dataSrc : [this.c.dataSrc];\n\t\tvar fn = DataTable.ext.oApi._fnGetObjectDataFn(fns[level]);\n\t\tvar dt = this.s.dt;\n\t\tvar group, last;\n\t\tvar data = [];\n\t\tvar that = this;\n\n\t\tfor (var i = 0, ien = rows.length; i < ien; i++) {\n\t\t\tvar rowIndex = rows[i];\n\t\t\tvar rowData = dt.row(rowIndex).data();\n\t\t\tvar group = fn(rowData);\n\n\t\t\tif (group === null || group === undefined) {\n\t\t\t\tgroup = that.c.emptyDataGroup;\n\t\t\t}\n\n\t\t\tif (last === undefined || group !== last) {\n\t\t\t\tdata.push({\n\t\t\t\t\tdataPoint: group,\n\t\t\t\t\trows: []\n\t\t\t\t});\n\n\t\t\t\tlast = group;\n\t\t\t}\n\n\t\t\tdata[data.length - 1].rows.push(rowIndex);\n\t\t}\n\n\t\tif (fns[level + 1] !== undefined) {\n\t\t\tfor (var i = 0, ien = data.length; i < ien; i++) {\n\t\t\t\tdata[i].children = this._group(level + 1, data[i].rows);\n\t\t\t}\n\t\t}\n\n\t\treturn data;\n\t},\n\n\t/**\n\t * Row group display - insert the rows into the document\n\t * @param {number} level Nesting level\n\t * @param {object[]} groups Takes the nested array from `_group`\n\t * @private\n\t */\n\t_groupDisplay: function (level, groups) {\n\t\tvar dt = this.s.dt;\n\t\tvar display;\n\n\t\tfor (var i = 0, ien = groups.length; i < ien; i++) {\n\t\t\tvar group = groups[i];\n\t\t\tvar groupName = group.dataPoint;\n\t\t\tvar row;\n\t\t\tvar rows = group.rows;\n\n\t\t\tif (this.c.startRender) {\n\t\t\t\tdisplay = this.c.startRender.call(this, dt.rows(rows), groupName, level);\n\t\t\t\trow = this._rowWrap(display, this.c.startClassName, level);\n\n\t\t\t\tif (row) {\n\t\t\t\t\trow.insertBefore(dt.row(rows[0]).node());\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (this.c.endRender) {\n\t\t\t\tdisplay = this.c.endRender.call(this, dt.rows(rows), groupName, level);\n\t\t\t\trow = this._rowWrap(display, this.c.endClassName, level);\n\n\t\t\t\tif (row) {\n\t\t\t\t\trow.insertAfter(dt.row(rows[rows.length - 1]).node());\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (group.children) {\n\t\t\t\tthis._groupDisplay(level + 1, group.children);\n\t\t\t}\n\t\t}\n\t},\n\n\t/**\n\t * Take a rendered value from an end user and make it suitable for display\n\t * as a row, by wrapping it in a row, or detecting that it is a row.\n\t * @param {node|jQuery|string} display Display value\n\t * @param {string} className Class to add to the row\n\t * @param {array} group\n\t * @param {number} group level\n\t * @private\n\t */\n\t_rowWrap: function (display, className, level) {\n\t\tvar row;\n\n\t\tif (display === null || display === '') {\n\t\t\tdisplay = this.c.emptyDataGroup;\n\t\t}\n\n\t\tif (display === undefined || display === null) {\n\t\t\treturn null;\n\t\t}\n\n\t\tif (\n\t\t\ttypeof display === 'object' &&\n\t\t\tdisplay.nodeName &&\n\t\t\tdisplay.nodeName.toLowerCase() === 'tr'\n\t\t) {\n\t\t\trow = $(display);\n\t\t}\n\t\telse if (\n\t\t\tdisplay instanceof $ &&\n\t\t\tdisplay.length &&\n\t\t\tdisplay[0].nodeName.toLowerCase() === 'tr'\n\t\t) {\n\t\t\trow = display;\n\t\t}\n\t\telse {\n\t\t\trow = $('<tr/>').append(\n\t\t\t\t$('<th/>').attr('colspan', this._colspan()).attr('scope', 'row').append(display)\n\t\t\t);\n\t\t}\n\n\t\treturn row\n\t\t\t.addClass(this.c.className)\n\t\t\t.addClass(className)\n\t\t\t.addClass('dtrg-level-' + level);\n\t}\n});\n\n/**\n * RowGroup default settings for initialisation\n *\n * @namespace\n * @name RowGroup.defaults\n * @static\n */\nRowGroup.defaults = {\n\t/**\n\t * Class to apply to grouping rows - applied to both the start and\n\t * end grouping rows.\n\t * @type string\n\t */\n\tclassName: 'dtrg-group',\n\n\t/**\n\t * Data property from which to read the grouping information\n\t * @type string|integer|array\n\t */\n\tdataSrc: 0,\n\n\t/**\n\t * Text to show if no data is found for a group\n\t * @type string\n\t */\n\temptyDataGroup: 'No group',\n\n\t/**\n\t * Initial enablement state\n\t * @boolean\n\t */\n\tenable: true,\n\n\t/**\n\t * Class name to give to the end grouping row\n\t * @type string\n\t */\n\tendClassName: 'dtrg-end',\n\n\t/**\n\t * End grouping label function\n\t * @function\n\t */\n\tendRender: null,\n\n\t/**\n\t * Class name to give to the start grouping row\n\t * @type string\n\t */\n\tstartClassName: 'dtrg-start',\n\n\t/**\n\t * Start grouping label function\n\t * @function\n\t */\n\tstartRender: function (rows, group) {\n\t\treturn group;\n\t}\n};\n\nRowGroup.version = '1.4.0';\n\n$.fn.dataTable.RowGroup = RowGroup;\n$.fn.DataTable.RowGroup = RowGroup;\n\nDataTable.Api.register('rowGroup()', function () {\n\treturn this;\n});\n\nDataTable.Api.register('rowGroup().disable()', function () {\n\treturn this.iterator('table', function (ctx) {\n\t\tif (ctx.rowGroup) {\n\t\t\tctx.rowGroup.enable(false);\n\t\t}\n\t});\n});\n\nDataTable.Api.register('rowGroup().enable()', function (opts) {\n\treturn this.iterator('table', function (ctx) {\n\t\tif (ctx.rowGroup) {\n\t\t\tctx.rowGroup.enable(opts === undefined ? true : opts);\n\t\t}\n\t});\n});\n\nDataTable.Api.register('rowGroup().enabled()', function () {\n\tvar ctx = this.context;\n\n\treturn ctx.length && ctx[0].rowGroup ? ctx[0].rowGroup.enabled() : false;\n});\n\nDataTable.Api.register('rowGroup().dataSrc()', function (val) {\n\tif (val === undefined) {\n\t\treturn this.context[0].rowGroup.dataSrc();\n\t}\n\n\treturn this.iterator('table', function (ctx) {\n\t\tif (ctx.rowGroup) {\n\t\t\tctx.rowGroup.dataSrc(val);\n\t\t}\n\t});\n});\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.dtrg', function (e, settings, json) {\n\tif (e.namespace !== 'dt') {\n\t\treturn;\n\t}\n\n\tvar init = settings.oInit.rowGroup;\n\tvar defaults = DataTable.defaults.rowGroup;\n\n\tif (init || defaults) {\n\t\tvar opts = $.extend({}, defaults, init);\n\n\t\tif (init !== false) {\n\t\t\tnew RowGroup(settings, opts);\n\t\t}\n\t}\n});\n\n\nexport default DataTable;\n","/*! DataTables 1.13.7\n * ©2008-2023 SpryMedia Ltd - datatables.net/license\n */\n\nimport jQuery from 'jquery';\n\n// DataTables code uses $ internally, but we want to be able to\n// reassign $ with the `use` method, so it is a regular var.\nvar $ = jQuery;\n\n\nvar DataTable = function ( selector, options )\n{\n\t// Check if called with a window or jQuery object for DOM less applications\n\t// This is for backwards compatibility\n\tif (DataTable.factory(selector, options)) {\n\t\treturn DataTable;\n\t}\n\n\t// When creating with `new`, create a new DataTable, returning the API instance\n\tif (this instanceof DataTable) {\n\t\treturn $(selector).DataTable(options);\n\t}\n\telse {\n\t\t// Argument switching\n\t\toptions = selector;\n\t}\n\n\t/**\n\t * Perform a jQuery selector action on the table's TR elements (from the tbody) and\n\t * return the resulting jQuery object.\n\t *  @param {string|node|jQuery} sSelector jQuery selector or node collection to act on\n\t *  @param {object} [oOpts] Optional parameters for modifying the rows to be included\n\t *  @param {string} [oOpts.filter=none] Select TR elements that meet the current filter\n\t *    criterion (\"applied\") or all TR elements (i.e. no filter).\n\t *  @param {string} [oOpts.order=current] Order of the TR elements in the processed array.\n\t *    Can be either 'current', whereby the current sorting of the table is used, or\n\t *    'original' whereby the original order the data was read into the table is used.\n\t *  @param {string} [oOpts.page=all] Limit the selection to the currently displayed page\n\t *    (\"current\") or not (\"all\"). If 'current' is given, then order is assumed to be\n\t *    'current' and filter is 'applied', regardless of what they might be given as.\n\t *  @returns {object} jQuery object, filtered by the given selector.\n\t *  @dtopt API\n\t *  @deprecated Since v1.10\n\t *\n\t *  @example\n\t *    $(document).ready(function() {\n\t *      var oTable = $('#example').dataTable();\n\t *\n\t *      // Highlight every second row\n\t *      oTable.$('tr:odd').css('backgroundColor', 'blue');\n\t *    } );\n\t *\n\t *  @example\n\t *    $(document).ready(function() {\n\t *      var oTable = $('#example').dataTable();\n\t *\n\t *      // Filter to rows with 'Webkit' in them, add a background colour and then\n\t *      // remove the filter, thus highlighting the 'Webkit' rows only.\n\t *      oTable.fnFilter('Webkit');\n\t *      oTable.$('tr', {\"search\": \"applied\"}).css('backgroundColor', 'blue');\n\t *      oTable.fnFilter('');\n\t *    } );\n\t */\n\tthis.$ = function ( sSelector, oOpts )\n\t{\n\t\treturn this.api(true).$( sSelector, oOpts );\n\t};\n\t\n\t\n\t/**\n\t * Almost identical to $ in operation, but in this case returns the data for the matched\n\t * rows - as such, the jQuery selector used should match TR row nodes or TD/TH cell nodes\n\t * rather than any descendants, so the data can be obtained for the row/cell. If matching\n\t * rows are found, the data returned is the original data array/object that was used to\n\t * create the row (or a generated array if from a DOM source).\n\t *\n\t * This method is often useful in-combination with $ where both functions are given the\n\t * same parameters and the array indexes will match identically.\n\t *  @param {string|node|jQuery} sSelector jQuery selector or node collection to act on\n\t *  @param {object} [oOpts] Optional parameters for modifying the rows to be included\n\t *  @param {string} [oOpts.filter=none] Select elements that meet the current filter\n\t *    criterion (\"applied\") or all elements (i.e. no filter).\n\t *  @param {string} [oOpts.order=current] Order of the data in the processed array.\n\t *    Can be either 'current', whereby the current sorting of the table is used, or\n\t *    'original' whereby the original order the data was read into the table is used.\n\t *  @param {string} [oOpts.page=all] Limit the selection to the currently displayed page\n\t *    (\"current\") or not (\"all\"). If 'current' is given, then order is assumed to be\n\t *    'current' and filter is 'applied', regardless of what they might be given as.\n\t *  @returns {array} Data for the matched elements. If any elements, as a result of the\n\t *    selector, were not TR, TD or TH elements in the DataTable, they will have a null\n\t *    entry in the array.\n\t *  @dtopt API\n\t *  @deprecated Since v1.10\n\t *\n\t *  @example\n\t *    $(document).ready(function() {\n\t *      var oTable = $('#example').dataTable();\n\t *\n\t *      // Get the data from the first row in the table\n\t *      var data = oTable._('tr:first');\n\t *\n\t *      // Do something useful with the data\n\t *      alert( \"First cell is: \"+data[0] );\n\t *    } );\n\t *\n\t *  @example\n\t *    $(document).ready(function() {\n\t *      var oTable = $('#example').dataTable();\n\t *\n\t *      // Filter to 'Webkit' and get all data for\n\t *      oTable.fnFilter('Webkit');\n\t *      var data = oTable._('tr', {\"search\": \"applied\"});\n\t *\n\t *      // Do something with the data\n\t *      alert( data.length+\" rows matched the search\" );\n\t *    } );\n\t */\n\tthis._ = function ( sSelector, oOpts )\n\t{\n\t\treturn this.api(true).rows( sSelector, oOpts ).data();\n\t};\n\t\n\t\n\t/**\n\t * Create a DataTables Api instance, with the currently selected tables for\n\t * the Api's context.\n\t * @param {boolean} [traditional=false] Set the API instance's context to be\n\t *   only the table referred to by the `DataTable.ext.iApiIndex` option, as was\n\t *   used in the API presented by DataTables 1.9- (i.e. the traditional mode),\n\t *   or if all tables captured in the jQuery object should be used.\n\t * @return {DataTables.Api}\n\t */\n\tthis.api = function ( traditional )\n\t{\n\t\treturn traditional ?\n\t\t\tnew _Api(\n\t\t\t\t_fnSettingsFromNode( this[ _ext.iApiIndex ] )\n\t\t\t) :\n\t\t\tnew _Api( this );\n\t};\n\t\n\t\n\t/**\n\t * Add a single new row or multiple rows of data to the table. Please note\n\t * that this is suitable for client-side processing only - if you are using\n\t * server-side processing (i.e. \"bServerSide\": true), then to add data, you\n\t * must add it to the data source, i.e. the server-side, through an Ajax call.\n\t *  @param {array|object} data The data to be added to the table. This can be:\n\t *    <ul>\n\t *      <li>1D array of data - add a single row with the data provided</li>\n\t *      <li>2D array of arrays - add multiple rows in a single call</li>\n\t *      <li>object - data object when using <i>mData</i></li>\n\t *      <li>array of objects - multiple data objects when using <i>mData</i></li>\n\t *    </ul>\n\t *  @param {bool} [redraw=true] redraw the table or not\n\t *  @returns {array} An array of integers, representing the list of indexes in\n\t *    <i>aoData</i> ({@link DataTable.models.oSettings}) that have been added to\n\t *    the table.\n\t *  @dtopt API\n\t *  @deprecated Since v1.10\n\t *\n\t *  @example\n\t *    // Global var for counter\n\t *    var giCount = 2;\n\t *\n\t *    $(document).ready(function() {\n\t *      $('#example').dataTable();\n\t *    } );\n\t *\n\t *    function fnClickAddRow() {\n\t *      $('#example').dataTable().fnAddData( [\n\t *        giCount+\".1\",\n\t *        giCount+\".2\",\n\t *        giCount+\".3\",\n\t *        giCount+\".4\" ]\n\t *      );\n\t *\n\t *      giCount++;\n\t *    }\n\t */\n\tthis.fnAddData = function( data, redraw )\n\t{\n\t\tvar api = this.api( true );\n\t\n\t\t/* Check if we want to add multiple rows or not */\n\t\tvar rows = Array.isArray(data) && ( Array.isArray(data[0]) || $.isPlainObject(data[0]) ) ?\n\t\t\tapi.rows.add( data ) :\n\t\t\tapi.row.add( data );\n\t\n\t\tif ( redraw === undefined || redraw ) {\n\t\t\tapi.draw();\n\t\t}\n\t\n\t\treturn rows.flatten().toArray();\n\t};\n\t\n\t\n\t/**\n\t * This function will make DataTables recalculate the column sizes, based on the data\n\t * contained in the table and the sizes applied to the columns (in the DOM, CSS or\n\t * through the sWidth parameter). This can be useful when the width of the table's\n\t * parent element changes (for example a window resize).\n\t *  @param {boolean} [bRedraw=true] Redraw the table or not, you will typically want to\n\t *  @dtopt API\n\t *  @deprecated Since v1.10\n\t *\n\t *  @example\n\t *    $(document).ready(function() {\n\t *      var oTable = $('#example').dataTable( {\n\t *        \"sScrollY\": \"200px\",\n\t *        \"bPaginate\": false\n\t *      } );\n\t *\n\t *      $(window).on('resize', function () {\n\t *        oTable.fnAdjustColumnSizing();\n\t *      } );\n\t *    } );\n\t */\n\tthis.fnAdjustColumnSizing = function ( bRedraw )\n\t{\n\t\tvar api = this.api( true ).columns.adjust();\n\t\tvar settings = api.settings()[0];\n\t\tvar scroll = settings.oScroll;\n\t\n\t\tif ( bRedraw === undefined || bRedraw ) {\n\t\t\tapi.draw( false );\n\t\t}\n\t\telse if ( scroll.sX !== \"\" || scroll.sY !== \"\" ) {\n\t\t\t/* If not redrawing, but scrolling, we want to apply the new column sizes anyway */\n\t\t\t_fnScrollDraw( settings );\n\t\t}\n\t};\n\t\n\t\n\t/**\n\t * Quickly and simply clear a table\n\t *  @param {bool} [bRedraw=true] redraw the table or not\n\t *  @dtopt API\n\t *  @deprecated Since v1.10\n\t *\n\t *  @example\n\t *    $(document).ready(function() {\n\t *      var oTable = $('#example').dataTable();\n\t *\n\t *      // Immediately 'nuke' the current rows (perhaps waiting for an Ajax callback...)\n\t *      oTable.fnClearTable();\n\t *    } );\n\t */\n\tthis.fnClearTable = function( bRedraw )\n\t{\n\t\tvar api = this.api( true ).clear();\n\t\n\t\tif ( bRedraw === undefined || bRedraw ) {\n\t\t\tapi.draw();\n\t\t}\n\t};\n\t\n\t\n\t/**\n\t * The exact opposite of 'opening' a row, this function will close any rows which\n\t * are currently 'open'.\n\t *  @param {node} nTr the table row to 'close'\n\t *  @returns {int} 0 on success, or 1 if failed (can't find the row)\n\t *  @dtopt API\n\t *  @deprecated Since v1.10\n\t *\n\t *  @example\n\t *    $(document).ready(function() {\n\t *      var oTable;\n\t *\n\t *      // 'open' an information row when a row is clicked on\n\t *      $('#example tbody tr').click( function () {\n\t *        if ( oTable.fnIsOpen(this) ) {\n\t *          oTable.fnClose( this );\n\t *        } else {\n\t *          oTable.fnOpen( this, \"Temporary row opened\", \"info_row\" );\n\t *        }\n\t *      } );\n\t *\n\t *      oTable = $('#example').dataTable();\n\t *    } );\n\t */\n\tthis.fnClose = function( nTr )\n\t{\n\t\tthis.api( true ).row( nTr ).child.hide();\n\t};\n\t\n\t\n\t/**\n\t * Remove a row for the table\n\t *  @param {mixed} target The index of the row from aoData to be deleted, or\n\t *    the TR element you want to delete\n\t *  @param {function|null} [callBack] Callback function\n\t *  @param {bool} [redraw=true] Redraw the table or not\n\t *  @returns {array} The row that was deleted\n\t *  @dtopt API\n\t *  @deprecated Since v1.10\n\t *\n\t *  @example\n\t *    $(document).ready(function() {\n\t *      var oTable = $('#example').dataTable();\n\t *\n\t *      // Immediately remove the first row\n\t *      oTable.fnDeleteRow( 0 );\n\t *    } );\n\t */\n\tthis.fnDeleteRow = function( target, callback, redraw )\n\t{\n\t\tvar api = this.api( true );\n\t\tvar rows = api.rows( target );\n\t\tvar settings = rows.settings()[0];\n\t\tvar data = settings.aoData[ rows[0][0] ];\n\t\n\t\trows.remove();\n\t\n\t\tif ( callback ) {\n\t\t\tcallback.call( this, settings, data );\n\t\t}\n\t\n\t\tif ( redraw === undefined || redraw ) {\n\t\t\tapi.draw();\n\t\t}\n\t\n\t\treturn data;\n\t};\n\t\n\t\n\t/**\n\t * Restore the table to it's original state in the DOM by removing all of DataTables\n\t * enhancements, alterations to the DOM structure of the table and event listeners.\n\t *  @param {boolean} [remove=false] Completely remove the table from the DOM\n\t *  @dtopt API\n\t *  @deprecated Since v1.10\n\t *\n\t *  @example\n\t *    $(document).ready(function() {\n\t *      // This example is fairly pointless in reality, but shows how fnDestroy can be used\n\t *      var oTable = $('#example').dataTable();\n\t *      oTable.fnDestroy();\n\t *    } );\n\t */\n\tthis.fnDestroy = function ( remove )\n\t{\n\t\tthis.api( true ).destroy( remove );\n\t};\n\t\n\t\n\t/**\n\t * Redraw the table\n\t *  @param {bool} [complete=true] Re-filter and resort (if enabled) the table before the draw.\n\t *  @dtopt API\n\t *  @deprecated Since v1.10\n\t *\n\t *  @example\n\t *    $(document).ready(function() {\n\t *      var oTable = $('#example').dataTable();\n\t *\n\t *      // Re-draw the table - you wouldn't want to do it here, but it's an example :-)\n\t *      oTable.fnDraw();\n\t *    } );\n\t */\n\tthis.fnDraw = function( complete )\n\t{\n\t\t// Note that this isn't an exact match to the old call to _fnDraw - it takes\n\t\t// into account the new data, but can hold position.\n\t\tthis.api( true ).draw( complete );\n\t};\n\t\n\t\n\t/**\n\t * Filter the input based on data\n\t *  @param {string} sInput String to filter the table on\n\t *  @param {int|null} [iColumn] Column to limit filtering to\n\t *  @param {bool} [bRegex=false] Treat as regular expression or not\n\t *  @param {bool} [bSmart=true] Perform smart filtering or not\n\t *  @param {bool} [bShowGlobal=true] Show the input global filter in it's input box(es)\n\t *  @param {bool} [bCaseInsensitive=true] Do case-insensitive matching (true) or not (false)\n\t *  @dtopt API\n\t *  @deprecated Since v1.10\n\t *\n\t *  @example\n\t *    $(document).ready(function() {\n\t *      var oTable = $('#example').dataTable();\n\t *\n\t *      // Sometime later - filter...\n\t *      oTable.fnFilter( 'test string' );\n\t *    } );\n\t */\n\tthis.fnFilter = function( sInput, iColumn, bRegex, bSmart, bShowGlobal, bCaseInsensitive )\n\t{\n\t\tvar api = this.api( true );\n\t\n\t\tif ( iColumn === null || iColumn === undefined ) {\n\t\t\tapi.search( sInput, bRegex, bSmart, bCaseInsensitive );\n\t\t}\n\t\telse {\n\t\t\tapi.column( iColumn ).search( sInput, bRegex, bSmart, bCaseInsensitive );\n\t\t}\n\t\n\t\tapi.draw();\n\t};\n\t\n\t\n\t/**\n\t * Get the data for the whole table, an individual row or an individual cell based on the\n\t * provided parameters.\n\t *  @param {int|node} [src] A TR row node, TD/TH cell node or an integer. If given as\n\t *    a TR node then the data source for the whole row will be returned. If given as a\n\t *    TD/TH cell node then iCol will be automatically calculated and the data for the\n\t *    cell returned. If given as an integer, then this is treated as the aoData internal\n\t *    data index for the row (see fnGetPosition) and the data for that row used.\n\t *  @param {int} [col] Optional column index that you want the data of.\n\t *  @returns {array|object|string} If mRow is undefined, then the data for all rows is\n\t *    returned. If mRow is defined, just data for that row, and is iCol is\n\t *    defined, only data for the designated cell is returned.\n\t *  @dtopt API\n\t *  @deprecated Since v1.10\n\t *\n\t *  @example\n\t *    // Row data\n\t *    $(document).ready(function() {\n\t *      oTable = $('#example').dataTable();\n\t *\n\t *      oTable.$('tr').click( function () {\n\t *        var data = oTable.fnGetData( this );\n\t *        // ... do something with the array / object of data for the row\n\t *      } );\n\t *    } );\n\t *\n\t *  @example\n\t *    // Individual cell data\n\t *    $(document).ready(function() {\n\t *      oTable = $('#example').dataTable();\n\t *\n\t *      oTable.$('td').click( function () {\n\t *        var sData = oTable.fnGetData( this );\n\t *        alert( 'The cell clicked on had the value of '+sData );\n\t *      } );\n\t *    } );\n\t */\n\tthis.fnGetData = function( src, col )\n\t{\n\t\tvar api = this.api( true );\n\t\n\t\tif ( src !== undefined ) {\n\t\t\tvar type = src.nodeName ? src.nodeName.toLowerCase() : '';\n\t\n\t\t\treturn col !== undefined || type == 'td' || type == 'th' ?\n\t\t\t\tapi.cell( src, col ).data() :\n\t\t\t\tapi.row( src ).data() || null;\n\t\t}\n\t\n\t\treturn api.data().toArray();\n\t};\n\t\n\t\n\t/**\n\t * Get an array of the TR nodes that are used in the table's body. Note that you will\n\t * typically want to use the '$' API method in preference to this as it is more\n\t * flexible.\n\t *  @param {int} [iRow] Optional row index for the TR element you want\n\t *  @returns {array|node} If iRow is undefined, returns an array of all TR elements\n\t *    in the table's body, or iRow is defined, just the TR element requested.\n\t *  @dtopt API\n\t *  @deprecated Since v1.10\n\t *\n\t *  @example\n\t *    $(document).ready(function() {\n\t *      var oTable = $('#example').dataTable();\n\t *\n\t *      // Get the nodes from the table\n\t *      var nNodes = oTable.fnGetNodes( );\n\t *    } );\n\t */\n\tthis.fnGetNodes = function( iRow )\n\t{\n\t\tvar api = this.api( true );\n\t\n\t\treturn iRow !== undefined ?\n\t\t\tapi.row( iRow ).node() :\n\t\t\tapi.rows().nodes().flatten().toArray();\n\t};\n\t\n\t\n\t/**\n\t * Get the array indexes of a particular cell from it's DOM element\n\t * and column index including hidden columns\n\t *  @param {node} node this can either be a TR, TD or TH in the table's body\n\t *  @returns {int} If nNode is given as a TR, then a single index is returned, or\n\t *    if given as a cell, an array of [row index, column index (visible),\n\t *    column index (all)] is given.\n\t *  @dtopt API\n\t *  @deprecated Since v1.10\n\t *\n\t *  @example\n\t *    $(document).ready(function() {\n\t *      $('#example tbody td').click( function () {\n\t *        // Get the position of the current data from the node\n\t *        var aPos = oTable.fnGetPosition( this );\n\t *\n\t *        // Get the data array for this row\n\t *        var aData = oTable.fnGetData( aPos[0] );\n\t *\n\t *        // Update the data array and return the value\n\t *        aData[ aPos[1] ] = 'clicked';\n\t *        this.innerHTML = 'clicked';\n\t *      } );\n\t *\n\t *      // Init DataTables\n\t *      oTable = $('#example').dataTable();\n\t *    } );\n\t */\n\tthis.fnGetPosition = function( node )\n\t{\n\t\tvar api = this.api( true );\n\t\tvar nodeName = node.nodeName.toUpperCase();\n\t\n\t\tif ( nodeName == 'TR' ) {\n\t\t\treturn api.row( node ).index();\n\t\t}\n\t\telse if ( nodeName == 'TD' || nodeName == 'TH' ) {\n\t\t\tvar cell = api.cell( node ).index();\n\t\n\t\t\treturn [\n\t\t\t\tcell.row,\n\t\t\t\tcell.columnVisible,\n\t\t\t\tcell.column\n\t\t\t];\n\t\t}\n\t\treturn null;\n\t};\n\t\n\t\n\t/**\n\t * Check to see if a row is 'open' or not.\n\t *  @param {node} nTr the table row to check\n\t *  @returns {boolean} true if the row is currently open, false otherwise\n\t *  @dtopt API\n\t *  @deprecated Since v1.10\n\t *\n\t *  @example\n\t *    $(document).ready(function() {\n\t *      var oTable;\n\t *\n\t *      // 'open' an information row when a row is clicked on\n\t *      $('#example tbody tr').click( function () {\n\t *        if ( oTable.fnIsOpen(this) ) {\n\t *          oTable.fnClose( this );\n\t *        } else {\n\t *          oTable.fnOpen( this, \"Temporary row opened\", \"info_row\" );\n\t *        }\n\t *      } );\n\t *\n\t *      oTable = $('#example').dataTable();\n\t *    } );\n\t */\n\tthis.fnIsOpen = function( nTr )\n\t{\n\t\treturn this.api( true ).row( nTr ).child.isShown();\n\t};\n\t\n\t\n\t/**\n\t * This function will place a new row directly after a row which is currently\n\t * on display on the page, with the HTML contents that is passed into the\n\t * function. This can be used, for example, to ask for confirmation that a\n\t * particular record should be deleted.\n\t *  @param {node} nTr The table row to 'open'\n\t *  @param {string|node|jQuery} mHtml The HTML to put into the row\n\t *  @param {string} sClass Class to give the new TD cell\n\t *  @returns {node} The row opened. Note that if the table row passed in as the\n\t *    first parameter, is not found in the table, this method will silently\n\t *    return.\n\t *  @dtopt API\n\t *  @deprecated Since v1.10\n\t *\n\t *  @example\n\t *    $(document).ready(function() {\n\t *      var oTable;\n\t *\n\t *      // 'open' an information row when a row is clicked on\n\t *      $('#example tbody tr').click( function () {\n\t *        if ( oTable.fnIsOpen(this) ) {\n\t *          oTable.fnClose( this );\n\t *        } else {\n\t *          oTable.fnOpen( this, \"Temporary row opened\", \"info_row\" );\n\t *        }\n\t *      } );\n\t *\n\t *      oTable = $('#example').dataTable();\n\t *    } );\n\t */\n\tthis.fnOpen = function( nTr, mHtml, sClass )\n\t{\n\t\treturn this.api( true )\n\t\t\t.row( nTr )\n\t\t\t.child( mHtml, sClass )\n\t\t\t.show()\n\t\t\t.child()[0];\n\t};\n\t\n\t\n\t/**\n\t * Change the pagination - provides the internal logic for pagination in a simple API\n\t * function. With this function you can have a DataTables table go to the next,\n\t * previous, first or last pages.\n\t *  @param {string|int} mAction Paging action to take: \"first\", \"previous\", \"next\" or \"last\"\n\t *    or page number to jump to (integer), note that page 0 is the first page.\n\t *  @param {bool} [bRedraw=true] Redraw the table or not\n\t *  @dtopt API\n\t *  @deprecated Since v1.10\n\t *\n\t *  @example\n\t *    $(document).ready(function() {\n\t *      var oTable = $('#example').dataTable();\n\t *      oTable.fnPageChange( 'next' );\n\t *    } );\n\t */\n\tthis.fnPageChange = function ( mAction, bRedraw )\n\t{\n\t\tvar api = this.api( true ).page( mAction );\n\t\n\t\tif ( bRedraw === undefined || bRedraw ) {\n\t\t\tapi.draw(false);\n\t\t}\n\t};\n\t\n\t\n\t/**\n\t * Show a particular column\n\t *  @param {int} iCol The column whose display should be changed\n\t *  @param {bool} bShow Show (true) or hide (false) the column\n\t *  @param {bool} [bRedraw=true] Redraw the table or not\n\t *  @dtopt API\n\t *  @deprecated Since v1.10\n\t *\n\t *  @example\n\t *    $(document).ready(function() {\n\t *      var oTable = $('#example').dataTable();\n\t *\n\t *      // Hide the second column after initialisation\n\t *      oTable.fnSetColumnVis( 1, false );\n\t *    } );\n\t */\n\tthis.fnSetColumnVis = function ( iCol, bShow, bRedraw )\n\t{\n\t\tvar api = this.api( true ).column( iCol ).visible( bShow );\n\t\n\t\tif ( bRedraw === undefined || bRedraw ) {\n\t\t\tapi.columns.adjust().draw();\n\t\t}\n\t};\n\t\n\t\n\t/**\n\t * Get the settings for a particular table for external manipulation\n\t *  @returns {object} DataTables settings object. See\n\t *    {@link DataTable.models.oSettings}\n\t *  @dtopt API\n\t *  @deprecated Since v1.10\n\t *\n\t *  @example\n\t *    $(document).ready(function() {\n\t *      var oTable = $('#example').dataTable();\n\t *      var oSettings = oTable.fnSettings();\n\t *\n\t *      // Show an example parameter from the settings\n\t *      alert( oSettings._iDisplayStart );\n\t *    } );\n\t */\n\tthis.fnSettings = function()\n\t{\n\t\treturn _fnSettingsFromNode( this[_ext.iApiIndex] );\n\t};\n\t\n\t\n\t/**\n\t * Sort the table by a particular column\n\t *  @param {int} iCol the data index to sort on. Note that this will not match the\n\t *    'display index' if you have hidden data entries\n\t *  @dtopt API\n\t *  @deprecated Since v1.10\n\t *\n\t *  @example\n\t *    $(document).ready(function() {\n\t *      var oTable = $('#example').dataTable();\n\t *\n\t *      // Sort immediately with columns 0 and 1\n\t *      oTable.fnSort( [ [0,'asc'], [1,'asc'] ] );\n\t *    } );\n\t */\n\tthis.fnSort = function( aaSort )\n\t{\n\t\tthis.api( true ).order( aaSort ).draw();\n\t};\n\t\n\t\n\t/**\n\t * Attach a sort listener to an element for a given column\n\t *  @param {node} nNode the element to attach the sort listener to\n\t *  @param {int} iColumn the column that a click on this node will sort on\n\t *  @param {function} [fnCallback] callback function when sort is run\n\t *  @dtopt API\n\t *  @deprecated Since v1.10\n\t *\n\t *  @example\n\t *    $(document).ready(function() {\n\t *      var oTable = $('#example').dataTable();\n\t *\n\t *      // Sort on column 1, when 'sorter' is clicked on\n\t *      oTable.fnSortListener( document.getElementById('sorter'), 1 );\n\t *    } );\n\t */\n\tthis.fnSortListener = function( nNode, iColumn, fnCallback )\n\t{\n\t\tthis.api( true ).order.listener( nNode, iColumn, fnCallback );\n\t};\n\t\n\t\n\t/**\n\t * Update a table cell or row - this method will accept either a single value to\n\t * update the cell with, an array of values with one element for each column or\n\t * an object in the same format as the original data source. The function is\n\t * self-referencing in order to make the multi column updates easier.\n\t *  @param {object|array|string} mData Data to update the cell/row with\n\t *  @param {node|int} mRow TR element you want to update or the aoData index\n\t *  @param {int} [iColumn] The column to update, give as null or undefined to\n\t *    update a whole row.\n\t *  @param {bool} [bRedraw=true] Redraw the table or not\n\t *  @param {bool} [bAction=true] Perform pre-draw actions or not\n\t *  @returns {int} 0 on success, 1 on error\n\t *  @dtopt API\n\t *  @deprecated Since v1.10\n\t *\n\t *  @example\n\t *    $(document).ready(function() {\n\t *      var oTable = $('#example').dataTable();\n\t *      oTable.fnUpdate( 'Example update', 0, 0 ); // Single cell\n\t *      oTable.fnUpdate( ['a', 'b', 'c', 'd', 'e'], $('tbody tr')[0] ); // Row\n\t *    } );\n\t */\n\tthis.fnUpdate = function( mData, mRow, iColumn, bRedraw, bAction )\n\t{\n\t\tvar api = this.api( true );\n\t\n\t\tif ( iColumn === undefined || iColumn === null ) {\n\t\t\tapi.row( mRow ).data( mData );\n\t\t}\n\t\telse {\n\t\t\tapi.cell( mRow, iColumn ).data( mData );\n\t\t}\n\t\n\t\tif ( bAction === undefined || bAction ) {\n\t\t\tapi.columns.adjust();\n\t\t}\n\t\n\t\tif ( bRedraw === undefined || bRedraw ) {\n\t\t\tapi.draw();\n\t\t}\n\t\treturn 0;\n\t};\n\t\n\t\n\t/**\n\t * Provide a common method for plug-ins to check the version of DataTables being used, in order\n\t * to ensure compatibility.\n\t *  @param {string} sVersion Version string to check for, in the format \"X.Y.Z\". Note that the\n\t *    formats \"X\" and \"X.Y\" are also acceptable.\n\t *  @returns {boolean} true if this version of DataTables is greater or equal to the required\n\t *    version, or false if this version of DataTales is not suitable\n\t *  @method\n\t *  @dtopt API\n\t *  @deprecated Since v1.10\n\t *\n\t *  @example\n\t *    $(document).ready(function() {\n\t *      var oTable = $('#example').dataTable();\n\t *      alert( oTable.fnVersionCheck( '1.9.0' ) );\n\t *    } );\n\t */\n\tthis.fnVersionCheck = _ext.fnVersionCheck;\n\t\n\n\tvar _that = this;\n\tvar emptyInit = options === undefined;\n\tvar len = this.length;\n\n\tif ( emptyInit ) {\n\t\toptions = {};\n\t}\n\n\tthis.oApi = this.internal = _ext.internal;\n\n\t// Extend with old style plug-in API methods\n\tfor ( var fn in DataTable.ext.internal ) {\n\t\tif ( fn ) {\n\t\t\tthis[fn] = _fnExternApiFunc(fn);\n\t\t}\n\t}\n\n\tthis.each(function() {\n\t\t// For each initialisation we want to give it a clean initialisation\n\t\t// object that can be bashed around\n\t\tvar o = {};\n\t\tvar oInit = len > 1 ? // optimisation for single table case\n\t\t\t_fnExtend( o, options, true ) :\n\t\t\toptions;\n\n\t\t/*global oInit,_that,emptyInit*/\n\t\tvar i=0, iLen, j, jLen, k, kLen;\n\t\tvar sId = this.getAttribute( 'id' );\n\t\tvar bInitHandedOff = false;\n\t\tvar defaults = DataTable.defaults;\n\t\tvar $this = $(this);\n\t\t\n\t\t\n\t\t/* Sanity check */\n\t\tif ( this.nodeName.toLowerCase() != 'table' )\n\t\t{\n\t\t\t_fnLog( null, 0, 'Non-table node initialisation ('+this.nodeName+')', 2 );\n\t\t\treturn;\n\t\t}\n\t\t\n\t\t/* Backwards compatibility for the defaults */\n\t\t_fnCompatOpts( defaults );\n\t\t_fnCompatCols( defaults.column );\n\t\t\n\t\t/* Convert the camel-case defaults to Hungarian */\n\t\t_fnCamelToHungarian( defaults, defaults, true );\n\t\t_fnCamelToHungarian( defaults.column, defaults.column, true );\n\t\t\n\t\t/* Setting up the initialisation object */\n\t\t_fnCamelToHungarian( defaults, $.extend( oInit, $this.data() ), true );\n\t\t\n\t\t\n\t\t\n\t\t/* Check to see if we are re-initialising a table */\n\t\tvar allSettings = DataTable.settings;\n\t\tfor ( i=0, iLen=allSettings.length ; i<iLen ; i++ )\n\t\t{\n\t\t\tvar s = allSettings[i];\n\t\t\n\t\t\t/* Base check on table node */\n\t\t\tif (\n\t\t\t\ts.nTable == this ||\n\t\t\t\t(s.nTHead && s.nTHead.parentNode == this) ||\n\t\t\t\t(s.nTFoot && s.nTFoot.parentNode == this)\n\t\t\t) {\n\t\t\t\tvar bRetrieve = oInit.bRetrieve !== undefined ? oInit.bRetrieve : defaults.bRetrieve;\n\t\t\t\tvar bDestroy = oInit.bDestroy !== undefined ? oInit.bDestroy : defaults.bDestroy;\n\t\t\n\t\t\t\tif ( emptyInit || bRetrieve )\n\t\t\t\t{\n\t\t\t\t\treturn s.oInstance;\n\t\t\t\t}\n\t\t\t\telse if ( bDestroy )\n\t\t\t\t{\n\t\t\t\t\ts.oInstance.fnDestroy();\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\t_fnLog( s, 0, 'Cannot reinitialise DataTable', 3 );\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t}\n\t\t\n\t\t\t/* If the element we are initialising has the same ID as a table which was previously\n\t\t\t * initialised, but the table nodes don't match (from before) then we destroy the old\n\t\t\t * instance by simply deleting it. This is under the assumption that the table has been\n\t\t\t * destroyed by other methods. Anyone using non-id selectors will need to do this manually\n\t\t\t */\n\t\t\tif ( s.sTableId == this.id )\n\t\t\t{\n\t\t\t\tallSettings.splice( i, 1 );\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\t\n\t\t/* Ensure the table has an ID - required for accessibility */\n\t\tif ( sId === null || sId === \"\" )\n\t\t{\n\t\t\tsId = \"DataTables_Table_\"+(DataTable.ext._unique++);\n\t\t\tthis.id = sId;\n\t\t}\n\t\t\n\t\t/* Create the settings object for this table and set some of the default parameters */\n\t\tvar oSettings = $.extend( true, {}, DataTable.models.oSettings, {\n\t\t\t\"sDestroyWidth\": $this[0].style.width,\n\t\t\t\"sInstance\":     sId,\n\t\t\t\"sTableId\":      sId\n\t\t} );\n\t\toSettings.nTable = this;\n\t\toSettings.oApi   = _that.internal;\n\t\toSettings.oInit  = oInit;\n\t\t\n\t\tallSettings.push( oSettings );\n\t\t\n\t\t// Need to add the instance after the instance after the settings object has been added\n\t\t// to the settings array, so we can self reference the table instance if more than one\n\t\toSettings.oInstance = (_that.length===1) ? _that : $this.dataTable();\n\t\t\n\t\t// Backwards compatibility, before we apply all the defaults\n\t\t_fnCompatOpts( oInit );\n\t\t_fnLanguageCompat( oInit.oLanguage );\n\t\t\n\t\t// If the length menu is given, but the init display length is not, use the length menu\n\t\tif ( oInit.aLengthMenu && ! oInit.iDisplayLength )\n\t\t{\n\t\t\toInit.iDisplayLength = Array.isArray( oInit.aLengthMenu[0] ) ?\n\t\t\t\toInit.aLengthMenu[0][0] : oInit.aLengthMenu[0];\n\t\t}\n\t\t\n\t\t// Apply the defaults and init options to make a single init object will all\n\t\t// options defined from defaults and instance options.\n\t\toInit = _fnExtend( $.extend( true, {}, defaults ), oInit );\n\t\t\n\t\t\n\t\t// Map the initialisation options onto the settings object\n\t\t_fnMap( oSettings.oFeatures, oInit, [\n\t\t\t\"bPaginate\",\n\t\t\t\"bLengthChange\",\n\t\t\t\"bFilter\",\n\t\t\t\"bSort\",\n\t\t\t\"bSortMulti\",\n\t\t\t\"bInfo\",\n\t\t\t\"bProcessing\",\n\t\t\t\"bAutoWidth\",\n\t\t\t\"bSortClasses\",\n\t\t\t\"bServerSide\",\n\t\t\t\"bDeferRender\"\n\t\t] );\n\t\t_fnMap( oSettings, oInit, [\n\t\t\t\"asStripeClasses\",\n\t\t\t\"ajax\",\n\t\t\t\"fnServerData\",\n\t\t\t\"fnFormatNumber\",\n\t\t\t\"sServerMethod\",\n\t\t\t\"aaSorting\",\n\t\t\t\"aaSortingFixed\",\n\t\t\t\"aLengthMenu\",\n\t\t\t\"sPaginationType\",\n\t\t\t\"sAjaxSource\",\n\t\t\t\"sAjaxDataProp\",\n\t\t\t\"iStateDuration\",\n\t\t\t\"sDom\",\n\t\t\t\"bSortCellsTop\",\n\t\t\t\"iTabIndex\",\n\t\t\t\"fnStateLoadCallback\",\n\t\t\t\"fnStateSaveCallback\",\n\t\t\t\"renderer\",\n\t\t\t\"searchDelay\",\n\t\t\t\"rowId\",\n\t\t\t[ \"iCookieDuration\", \"iStateDuration\" ], // backwards compat\n\t\t\t[ \"oSearch\", \"oPreviousSearch\" ],\n\t\t\t[ \"aoSearchCols\", \"aoPreSearchCols\" ],\n\t\t\t[ \"iDisplayLength\", \"_iDisplayLength\" ]\n\t\t] );\n\t\t_fnMap( oSettings.oScroll, oInit, [\n\t\t\t[ \"sScrollX\", \"sX\" ],\n\t\t\t[ \"sScrollXInner\", \"sXInner\" ],\n\t\t\t[ \"sScrollY\", \"sY\" ],\n\t\t\t[ \"bScrollCollapse\", \"bCollapse\" ]\n\t\t] );\n\t\t_fnMap( oSettings.oLanguage, oInit, \"fnInfoCallback\" );\n\t\t\n\t\t/* Callback functions which are array driven */\n\t\t_fnCallbackReg( oSettings, 'aoDrawCallback',       oInit.fnDrawCallback,      'user' );\n\t\t_fnCallbackReg( oSettings, 'aoServerParams',       oInit.fnServerParams,      'user' );\n\t\t_fnCallbackReg( oSettings, 'aoStateSaveParams',    oInit.fnStateSaveParams,   'user' );\n\t\t_fnCallbackReg( oSettings, 'aoStateLoadParams',    oInit.fnStateLoadParams,   'user' );\n\t\t_fnCallbackReg( oSettings, 'aoStateLoaded',        oInit.fnStateLoaded,       'user' );\n\t\t_fnCallbackReg( oSettings, 'aoRowCallback',        oInit.fnRowCallback,       'user' );\n\t\t_fnCallbackReg( oSettings, 'aoRowCreatedCallback', oInit.fnCreatedRow,        'user' );\n\t\t_fnCallbackReg( oSettings, 'aoHeaderCallback',     oInit.fnHeaderCallback,    'user' );\n\t\t_fnCallbackReg( oSettings, 'aoFooterCallback',     oInit.fnFooterCallback,    'user' );\n\t\t_fnCallbackReg( oSettings, 'aoInitComplete',       oInit.fnInitComplete,      'user' );\n\t\t_fnCallbackReg( oSettings, 'aoPreDrawCallback',    oInit.fnPreDrawCallback,   'user' );\n\t\t\n\t\toSettings.rowIdFn = _fnGetObjectDataFn( oInit.rowId );\n\t\t\n\t\t/* Browser support detection */\n\t\t_fnBrowserDetect( oSettings );\n\t\t\n\t\tvar oClasses = oSettings.oClasses;\n\t\t\n\t\t$.extend( oClasses, DataTable.ext.classes, oInit.oClasses );\n\t\t$this.addClass( oClasses.sTable );\n\t\t\n\t\t\n\t\tif ( oSettings.iInitDisplayStart === undefined )\n\t\t{\n\t\t\t/* Display start point, taking into account the save saving */\n\t\t\toSettings.iInitDisplayStart = oInit.iDisplayStart;\n\t\t\toSettings._iDisplayStart = oInit.iDisplayStart;\n\t\t}\n\t\t\n\t\tif ( oInit.iDeferLoading !== null )\n\t\t{\n\t\t\toSettings.bDeferLoading = true;\n\t\t\tvar tmp = Array.isArray( oInit.iDeferLoading );\n\t\t\toSettings._iRecordsDisplay = tmp ? oInit.iDeferLoading[0] : oInit.iDeferLoading;\n\t\t\toSettings._iRecordsTotal = tmp ? oInit.iDeferLoading[1] : oInit.iDeferLoading;\n\t\t}\n\t\t\n\t\t/* Language definitions */\n\t\tvar oLanguage = oSettings.oLanguage;\n\t\t$.extend( true, oLanguage, oInit.oLanguage );\n\t\t\n\t\tif ( oLanguage.sUrl )\n\t\t{\n\t\t\t/* Get the language definitions from a file - because this Ajax call makes the language\n\t\t\t * get async to the remainder of this function we use bInitHandedOff to indicate that\n\t\t\t * _fnInitialise will be fired by the returned Ajax handler, rather than the constructor\n\t\t\t */\n\t\t\t$.ajax( {\n\t\t\t\tdataType: 'json',\n\t\t\t\turl: oLanguage.sUrl,\n\t\t\t\tsuccess: function ( json ) {\n\t\t\t\t\t_fnCamelToHungarian( defaults.oLanguage, json );\n\t\t\t\t\t_fnLanguageCompat( json );\n\t\t\t\t\t$.extend( true, oLanguage, json, oSettings.oInit.oLanguage );\n\t\t\n\t\t\t\t\t_fnCallbackFire( oSettings, null, 'i18n', [oSettings]);\n\t\t\t\t\t_fnInitialise( oSettings );\n\t\t\t\t},\n\t\t\t\terror: function () {\n\t\t\t\t\t// Error occurred loading language file, continue on as best we can\n\t\t\t\t\t_fnInitialise( oSettings );\n\t\t\t\t}\n\t\t\t} );\n\t\t\tbInitHandedOff = true;\n\t\t}\n\t\telse {\n\t\t\t_fnCallbackFire( oSettings, null, 'i18n', [oSettings]);\n\t\t}\n\t\t\n\t\t/*\n\t\t * Stripes\n\t\t */\n\t\tif ( oInit.asStripeClasses === null )\n\t\t{\n\t\t\toSettings.asStripeClasses =[\n\t\t\t\toClasses.sStripeOdd,\n\t\t\t\toClasses.sStripeEven\n\t\t\t];\n\t\t}\n\t\t\n\t\t/* Remove row stripe classes if they are already on the table row */\n\t\tvar stripeClasses = oSettings.asStripeClasses;\n\t\tvar rowOne = $this.children('tbody').find('tr').eq(0);\n\t\tif ( $.inArray( true, $.map( stripeClasses, function(el, i) {\n\t\t\treturn rowOne.hasClass(el);\n\t\t} ) ) !== -1 ) {\n\t\t\t$('tbody tr', this).removeClass( stripeClasses.join(' ') );\n\t\t\toSettings.asDestroyStripes = stripeClasses.slice();\n\t\t}\n\t\t\n\t\t/*\n\t\t * Columns\n\t\t * See if we should load columns automatically or use defined ones\n\t\t */\n\t\tvar anThs = [];\n\t\tvar aoColumnsInit;\n\t\tvar nThead = this.getElementsByTagName('thead');\n\t\tif ( nThead.length !== 0 )\n\t\t{\n\t\t\t_fnDetectHeader( oSettings.aoHeader, nThead[0] );\n\t\t\tanThs = _fnGetUniqueThs( oSettings );\n\t\t}\n\t\t\n\t\t/* If not given a column array, generate one with nulls */\n\t\tif ( oInit.aoColumns === null )\n\t\t{\n\t\t\taoColumnsInit = [];\n\t\t\tfor ( i=0, iLen=anThs.length ; i<iLen ; i++ )\n\t\t\t{\n\t\t\t\taoColumnsInit.push( null );\n\t\t\t}\n\t\t}\n\t\telse\n\t\t{\n\t\t\taoColumnsInit = oInit.aoColumns;\n\t\t}\n\t\t\n\t\t/* Add the columns */\n\t\tfor ( i=0, iLen=aoColumnsInit.length ; i<iLen ; i++ )\n\t\t{\n\t\t\t_fnAddColumn( oSettings, anThs ? anThs[i] : null );\n\t\t}\n\t\t\n\t\t/* Apply the column definitions */\n\t\t_fnApplyColumnDefs( oSettings, oInit.aoColumnDefs, aoColumnsInit, function (iCol, oDef) {\n\t\t\t_fnColumnOptions( oSettings, iCol, oDef );\n\t\t} );\n\t\t\n\t\t/* HTML5 attribute detection - build an mData object automatically if the\n\t\t * attributes are found\n\t\t */\n\t\tif ( rowOne.length ) {\n\t\t\tvar a = function ( cell, name ) {\n\t\t\t\treturn cell.getAttribute( 'data-'+name ) !== null ? name : null;\n\t\t\t};\n\t\t\n\t\t\t$( rowOne[0] ).children('th, td').each( function (i, cell) {\n\t\t\t\tvar col = oSettings.aoColumns[i];\n\t\t\n\t\t\t\tif (! col) {\n\t\t\t\t\t_fnLog( oSettings, 0, 'Incorrect column count', 18 );\n\t\t\t\t}\n\t\t\n\t\t\t\tif ( col.mData === i ) {\n\t\t\t\t\tvar sort = a( cell, 'sort' ) || a( cell, 'order' );\n\t\t\t\t\tvar filter = a( cell, 'filter' ) || a( cell, 'search' );\n\t\t\n\t\t\t\t\tif ( sort !== null || filter !== null ) {\n\t\t\t\t\t\tcol.mData = {\n\t\t\t\t\t\t\t_:      i+'.display',\n\t\t\t\t\t\t\tsort:   sort !== null   ? i+'.@data-'+sort   : undefined,\n\t\t\t\t\t\t\ttype:   sort !== null   ? i+'.@data-'+sort   : undefined,\n\t\t\t\t\t\t\tfilter: filter !== null ? i+'.@data-'+filter : undefined\n\t\t\t\t\t\t};\n\t\t\t\t\t\tcol._isArrayHost = true;\n\t\t\n\t\t\t\t\t\t_fnColumnOptions( oSettings, i );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\t\t\n\t\tvar features = oSettings.oFeatures;\n\t\tvar loadedInit = function () {\n\t\t\t/*\n\t\t\t * Sorting\n\t\t\t * @todo For modularisation (1.11) this needs to do into a sort start up handler\n\t\t\t */\n\t\t\n\t\t\t// If aaSorting is not defined, then we use the first indicator in asSorting\n\t\t\t// in case that has been altered, so the default sort reflects that option\n\t\t\tif ( oInit.aaSorting === undefined ) {\n\t\t\t\tvar sorting = oSettings.aaSorting;\n\t\t\t\tfor ( i=0, iLen=sorting.length ; i<iLen ; i++ ) {\n\t\t\t\t\tsorting[i][1] = oSettings.aoColumns[ i ].asSorting[0];\n\t\t\t\t}\n\t\t\t}\n\t\t\n\t\t\t/* Do a first pass on the sorting classes (allows any size changes to be taken into\n\t\t\t * account, and also will apply sorting disabled classes if disabled\n\t\t\t */\n\t\t\t_fnSortingClasses( oSettings );\n\t\t\n\t\t\tif ( features.bSort ) {\n\t\t\t\t_fnCallbackReg( oSettings, 'aoDrawCallback', function () {\n\t\t\t\t\tif ( oSettings.bSorted ) {\n\t\t\t\t\t\tvar aSort = _fnSortFlatten( oSettings );\n\t\t\t\t\t\tvar sortedColumns = {};\n\t\t\n\t\t\t\t\t\t$.each( aSort, function (i, val) {\n\t\t\t\t\t\t\tsortedColumns[ val.src ] = val.dir;\n\t\t\t\t\t\t} );\n\t\t\n\t\t\t\t\t\t_fnCallbackFire( oSettings, null, 'order', [oSettings, aSort, sortedColumns] );\n\t\t\t\t\t\t_fnSortAria( oSettings );\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t\t}\n\t\t\n\t\t\t_fnCallbackReg( oSettings, 'aoDrawCallback', function () {\n\t\t\t\tif ( oSettings.bSorted || _fnDataSource( oSettings ) === 'ssp' || features.bDeferRender ) {\n\t\t\t\t\t_fnSortingClasses( oSettings );\n\t\t\t\t}\n\t\t\t}, 'sc' );\n\t\t\n\t\t\n\t\t\t/*\n\t\t\t * Final init\n\t\t\t * Cache the header, body and footer as required, creating them if needed\n\t\t\t */\n\t\t\n\t\t\t// Work around for Webkit bug 83867 - store the caption-side before removing from doc\n\t\t\tvar captions = $this.children('caption').each( function () {\n\t\t\t\tthis._captionSide = $(this).css('caption-side');\n\t\t\t} );\n\t\t\n\t\t\tvar thead = $this.children('thead');\n\t\t\tif ( thead.length === 0 ) {\n\t\t\t\tthead = $('<thead/>').appendTo($this);\n\t\t\t}\n\t\t\toSettings.nTHead = thead[0];\n\t\t\n\t\t\tvar tbody = $this.children('tbody');\n\t\t\tif ( tbody.length === 0 ) {\n\t\t\t\ttbody = $('<tbody/>').insertAfter(thead);\n\t\t\t}\n\t\t\toSettings.nTBody = tbody[0];\n\t\t\n\t\t\tvar tfoot = $this.children('tfoot');\n\t\t\tif ( tfoot.length === 0 && captions.length > 0 && (oSettings.oScroll.sX !== \"\" || oSettings.oScroll.sY !== \"\") ) {\n\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// a tfoot element for the caption element to be appended to\n\t\t\t\ttfoot = $('<tfoot/>').appendTo($this);\n\t\t\t}\n\t\t\n\t\t\tif ( tfoot.length === 0 || tfoot.children().length === 0 ) {\n\t\t\t\t$this.addClass( oClasses.sNoFooter );\n\t\t\t}\n\t\t\telse if ( tfoot.length > 0 ) {\n\t\t\t\toSettings.nTFoot = tfoot[0];\n\t\t\t\t_fnDetectHeader( oSettings.aoFooter, oSettings.nTFoot );\n\t\t\t}\n\t\t\n\t\t\t/* Check if there is data passing into the constructor */\n\t\t\tif ( oInit.aaData ) {\n\t\t\t\tfor ( i=0 ; i<oInit.aaData.length ; i++ ) {\n\t\t\t\t\t_fnAddData( oSettings, oInit.aaData[ i ] );\n\t\t\t\t}\n\t\t\t}\n\t\t\telse if ( oSettings.bDeferLoading || _fnDataSource( oSettings ) == 'dom' ) {\n\t\t\t\t/* Grab the data from the page - only do this when deferred loading or no Ajax\n\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 * to replace it with Ajax data\n\t\t\t\t */\n\t\t\t\t_fnAddTr( oSettings, $(oSettings.nTBody).children('tr') );\n\t\t\t}\n\t\t\n\t\t\t/* Copy the data index array */\n\t\t\toSettings.aiDisplay = oSettings.aiDisplayMaster.slice();\n\t\t\n\t\t\t/* Initialisation complete - table can be drawn */\n\t\t\toSettings.bInitialised = true;\n\t\t\n\t\t\t/* Check if we need to initialise the table (it might not have been handed off to the\n\t\t\t * language processor)\n\t\t\t */\n\t\t\tif ( bInitHandedOff === false ) {\n\t\t\t\t_fnInitialise( oSettings );\n\t\t\t}\n\t\t};\n\t\t\n\t\t/* Must be done after everything which can be overridden by the state saving! */\n\t\t_fnCallbackReg( oSettings, 'aoDrawCallback', _fnSaveState, 'state_save' );\n\t\t\n\t\tif ( oInit.bStateSave )\n\t\t{\n\t\t\tfeatures.bStateSave = true;\n\t\t\t_fnLoadState( oSettings, oInit, loadedInit );\n\t\t}\n\t\telse {\n\t\t\tloadedInit();\n\t\t}\n\t\t\n\t} );\n\t_that = null;\n\treturn this;\n};\n\n\n/*\n * It is useful to have variables which are scoped locally so only the\n * DataTables functions can access them and they don't leak into global space.\n * At the same time these functions are often useful over multiple files in the\n * core and API, so we list, or at least document, all variables which are used\n * by DataTables as private variables here. This also ensures that there is no\n * clashing of variable names and that they can easily referenced for reuse.\n */\n\n\n// Defined else where\n//  _selector_run\n//  _selector_opts\n//  _selector_first\n//  _selector_row_indexes\n\nvar _ext; // DataTable.ext\nvar _Api; // DataTable.Api\nvar _api_register; // DataTable.Api.register\nvar _api_registerPlural; // DataTable.Api.registerPlural\n\nvar _re_dic = {};\nvar _re_new_lines = /[\\r\\n\\u2028]/g;\nvar _re_html = /<.*?>/g;\n\n// This is not strict ISO8601 - Date.parse() is quite lax, although\n// implementations differ between browsers.\nvar _re_date = /^\\d{2,4}[\\.\\/\\-]\\d{1,2}[\\.\\/\\-]\\d{1,2}([T ]{1}\\d{1,2}[:\\.]\\d{2}([\\.:]\\d{2})?)?$/;\n\n// Escape regular expression special characters\nvar _re_escape_regex = new RegExp( '(\\\\' + [ '/', '.', '*', '+', '?', '|', '(', ')', '[', ']', '{', '}', '\\\\', '$', '^', '-' ].join('|\\\\') + ')', 'g' );\n\n// https://en.wikipedia.org/wiki/Foreign_exchange_market\n// - \\u20BD - Russian ruble.\n// - \\u20a9 - South Korean Won\n// - \\u20BA - Turkish Lira\n// - \\u20B9 - Indian Rupee\n// - R - Brazil (R$) and South Africa\n// - fr - Swiss Franc\n// - kr - Swedish krona, Norwegian krone and Danish krone\n// - \\u2009 is thin space and \\u202F is narrow no-break space, both used in many\n// - Ƀ - Bitcoin\n// - Ξ - Ethereum\n//   standards as thousands separators.\nvar _re_formatted_numeric = /['\\u00A0,$£€¥%\\u2009\\u202F\\u20BD\\u20a9\\u20BArfkɃΞ]/gi;\n\n\nvar _empty = function ( d ) {\n\treturn !d || d === true || d === '-' ? true : false;\n};\n\n\nvar _intVal = function ( s ) {\n\tvar integer = parseInt( s, 10 );\n\treturn !isNaN(integer) && isFinite(s) ? integer : null;\n};\n\n// Convert from a formatted number with characters other than `.` as the\n// decimal place, to a Javascript number\nvar _numToDecimal = function ( num, decimalPoint ) {\n\t// Cache created regular expressions for speed as this function is called often\n\tif ( ! _re_dic[ decimalPoint ] ) {\n\t\t_re_dic[ decimalPoint ] = new RegExp( _fnEscapeRegex( decimalPoint ), 'g' );\n\t}\n\treturn typeof num === 'string' && decimalPoint !== '.' ?\n\t\tnum.replace( /\\./g, '' ).replace( _re_dic[ decimalPoint ], '.' ) :\n\t\tnum;\n};\n\n\nvar _isNumber = function ( d, decimalPoint, formatted ) {\n\tvar type = typeof d;\n\tvar strType = type === 'string';\n\n\tif ( type === 'number' || type === 'bigint') {\n\t\treturn true;\n\t}\n\n\t// If empty return immediately so there must be a number if it is a\n\t// formatted string (this stops the string \"k\", or \"kr\", etc being detected\n\t// as a formatted number for currency\n\tif ( _empty( d ) ) {\n\t\treturn true;\n\t}\n\n\tif ( decimalPoint && strType ) {\n\t\td = _numToDecimal( d, decimalPoint );\n\t}\n\n\tif ( formatted && strType ) {\n\t\td = d.replace( _re_formatted_numeric, '' );\n\t}\n\n\treturn !isNaN( parseFloat(d) ) && isFinite( d );\n};\n\n\n// A string without HTML in it can be considered to be HTML still\nvar _isHtml = function ( d ) {\n\treturn _empty( d ) || typeof d === 'string';\n};\n\n\nvar _htmlNumeric = function ( d, decimalPoint, formatted ) {\n\tif ( _empty( d ) ) {\n\t\treturn true;\n\t}\n\n\tvar html = _isHtml( d );\n\treturn ! html ?\n\t\tnull :\n\t\t_isNumber( _stripHtml( d ), decimalPoint, formatted ) ?\n\t\t\ttrue :\n\t\t\tnull;\n};\n\n\nvar _pluck = function ( a, prop, prop2 ) {\n\tvar out = [];\n\tvar i=0, ien=a.length;\n\n\t// Could have the test in the loop for slightly smaller code, but speed\n\t// is essential here\n\tif ( prop2 !== undefined ) {\n\t\tfor ( ; i<ien ; i++ ) {\n\t\t\tif ( a[i] && a[i][ prop ] ) {\n\t\t\t\tout.push( a[i][ prop ][ prop2 ] );\n\t\t\t}\n\t\t}\n\t}\n\telse {\n\t\tfor ( ; i<ien ; i++ ) {\n\t\t\tif ( a[i] ) {\n\t\t\t\tout.push( a[i][ prop ] );\n\t\t\t}\n\t\t}\n\t}\n\n\treturn out;\n};\n\n\n// Basically the same as _pluck, but rather than looping over `a` we use `order`\n// as the indexes to pick from `a`\nvar _pluck_order = function ( a, order, prop, prop2 )\n{\n\tvar out = [];\n\tvar i=0, ien=order.length;\n\n\t// Could have the test in the loop for slightly smaller code, but speed\n\t// is essential here\n\tif ( prop2 !== undefined ) {\n\t\tfor ( ; i<ien ; i++ ) {\n\t\t\tif ( a[ order[i] ][ prop ] ) {\n\t\t\t\tout.push( a[ order[i] ][ prop ][ prop2 ] );\n\t\t\t}\n\t\t}\n\t}\n\telse {\n\t\tfor ( ; i<ien ; i++ ) {\n\t\t\tout.push( a[ order[i] ][ prop ] );\n\t\t}\n\t}\n\n\treturn out;\n};\n\n\nvar _range = function ( len, start )\n{\n\tvar out = [];\n\tvar end;\n\n\tif ( start === undefined ) {\n\t\tstart = 0;\n\t\tend = len;\n\t}\n\telse {\n\t\tend = start;\n\t\tstart = len;\n\t}\n\n\tfor ( var i=start ; i<end ; i++ ) {\n\t\tout.push( i );\n\t}\n\n\treturn out;\n};\n\n\nvar _removeEmpty = function ( a )\n{\n\tvar out = [];\n\n\tfor ( var i=0, ien=a.length ; i<ien ; i++ ) {\n\t\tif ( a[i] ) { // careful - will remove all falsy values!\n\t\t\tout.push( a[i] );\n\t\t}\n\t}\n\n\treturn out;\n};\n\n\nvar _stripHtml = function ( d ) {\n\treturn d\n\t\t.replace( _re_html, '' ) // Complete tags\n\t\t.replace(/<script/i, ''); // Safety for incomplete script tag\n};\n\n\n/**\n * Determine if all values in the array are unique. This means we can short\n * cut the _unique method at the cost of a single loop. A sorted array is used\n * to easily check the values.\n *\n * @param  {array} src Source array\n * @return {boolean} true if all unique, false otherwise\n * @ignore\n */\nvar _areAllUnique = function ( src ) {\n\tif ( src.length < 2 ) {\n\t\treturn true;\n\t}\n\n\tvar sorted = src.slice().sort();\n\tvar last = sorted[0];\n\n\tfor ( var i=1, ien=sorted.length ; i<ien ; i++ ) {\n\t\tif ( sorted[i] === last ) {\n\t\t\treturn false;\n\t\t}\n\n\t\tlast = sorted[i];\n\t}\n\n\treturn true;\n};\n\n\n/**\n * Find the unique elements in a source array.\n *\n * @param  {array} src Source array\n * @return {array} Array of unique items\n * @ignore\n */\nvar _unique = function ( src )\n{\n\tif ( _areAllUnique( src ) ) {\n\t\treturn src.slice();\n\t}\n\n\t// A faster unique method is to use object keys to identify used values,\n\t// but this doesn't work with arrays or objects, which we must also\n\t// consider. See jsperf.com/compare-array-unique-versions/4 for more\n\t// information.\n\tvar\n\t\tout = [],\n\t\tval,\n\t\ti, ien=src.length,\n\t\tj, k=0;\n\n\tagain: for ( i=0 ; i<ien ; i++ ) {\n\t\tval = src[i];\n\n\t\tfor ( j=0 ; j<k ; j++ ) {\n\t\t\tif ( out[j] === val ) {\n\t\t\t\tcontinue again;\n\t\t\t}\n\t\t}\n\n\t\tout.push( val );\n\t\tk++;\n\t}\n\n\treturn out;\n};\n\n// Surprisingly this is faster than [].concat.apply\n// https://jsperf.com/flatten-an-array-loop-vs-reduce/2\nvar _flatten = function (out, val) {\n\tif (Array.isArray(val)) {\n\t\tfor (var i=0 ; i<val.length ; i++) {\n\t\t\t_flatten(out, val[i]);\n\t\t}\n\t}\n\telse {\n\t\tout.push(val);\n\t}\n  \n\treturn out;\n}\n\nvar _includes = function (search, start) {\n\tif (start === undefined) {\n\t\tstart = 0;\n\t}\n\n\treturn this.indexOf(search, start) !== -1;\t\n};\n\n// Array.isArray polyfill.\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray\nif (! Array.isArray) {\n    Array.isArray = function(arg) {\n        return Object.prototype.toString.call(arg) === '[object Array]';\n    };\n}\n\nif (! Array.prototype.includes) {\n\tArray.prototype.includes = _includes;\n}\n\n// .trim() polyfill\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/trim\nif (!String.prototype.trim) {\n  String.prototype.trim = function () {\n    return this.replace(/^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g, '');\n  };\n}\n\nif (! String.prototype.includes) {\n\tString.prototype.includes = _includes;\n}\n\n/**\n * DataTables utility methods\n * \n * This namespace provides helper methods that DataTables uses internally to\n * create a DataTable, but which are not exclusively used only for DataTables.\n * These methods can be used by extension authors to save the duplication of\n * code.\n *\n *  @namespace\n */\nDataTable.util = {\n\t/**\n\t * Throttle the calls to a function. Arguments and context are maintained\n\t * for the throttled function.\n\t *\n\t * @param {function} fn Function to be called\n\t * @param {integer} freq Call frequency in mS\n\t * @return {function} Wrapped function\n\t */\n\tthrottle: function ( fn, freq ) {\n\t\tvar\n\t\t\tfrequency = freq !== undefined ? freq : 200,\n\t\t\tlast,\n\t\t\ttimer;\n\n\t\treturn function () {\n\t\t\tvar\n\t\t\t\tthat = this,\n\t\t\t\tnow  = +new Date(),\n\t\t\t\targs = arguments;\n\n\t\t\tif ( last && now < last + frequency ) {\n\t\t\t\tclearTimeout( timer );\n\n\t\t\t\ttimer = setTimeout( function () {\n\t\t\t\t\tlast = undefined;\n\t\t\t\t\tfn.apply( that, args );\n\t\t\t\t}, frequency );\n\t\t\t}\n\t\t\telse {\n\t\t\t\tlast = now;\n\t\t\t\tfn.apply( that, args );\n\t\t\t}\n\t\t};\n\t},\n\n\n\t/**\n\t * Escape a string such that it can be used in a regular expression\n\t *\n\t *  @param {string} val string to escape\n\t *  @returns {string} escaped string\n\t */\n\tescapeRegex: function ( val ) {\n\t\treturn val.replace( _re_escape_regex, '\\\\$1' );\n\t},\n\n\t/**\n\t * Create a function that will write to a nested object or array\n\t * @param {*} source JSON notation string\n\t * @returns Write function\n\t */\n\tset: function ( source ) {\n\t\tif ( $.isPlainObject( source ) ) {\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 DataTable.util.set( source._ );\n\t\t}\n\t\telse if ( source === null ) {\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 source === 'function' ) {\n\t\t\treturn function (data, val, meta) {\n\t\t\t\tsource( data, 'set', val, meta );\n\t\t\t};\n\t\t}\n\t\telse if ( typeof source === 'string' && (source.indexOf('.') !== -1 ||\n\t\t\t\t  source.indexOf('[') !== -1 || source.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\t// Protect against prototype pollution\n\t\t\t\t\tif (a[i] === '__proto__' || a[i] === 'constructor') {\n\t\t\t\t\t\tthrow new Error('Cannot set prototype values');\n\t\t\t\t\t}\n\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\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 ( Array.isArray( val ) ) {\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\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\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\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\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\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\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, source );\n\t\t\t};\n\t\t}\n\t\telse {\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[source] = val;\n\t\t\t};\n\t\t}\n\t},\n\n\t/**\n\t * Create a function that will read nested objects from arrays, based on JSON notation\n\t * @param {*} source JSON notation string\n\t * @returns Value read\n\t */\n\tget: function ( source ) {\n\t\tif ( $.isPlainObject( source ) ) {\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( source, function (key, val) {\n\t\t\t\tif ( val ) {\n\t\t\t\t\to[key] = DataTable.util.get( 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 ( source === null ) {\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 source === 'function' ) {\n\t\t\treturn function (data, type, row, meta) {\n\t\t\t\treturn source( data, type, row, meta );\n\t\t\t};\n\t\t}\n\t\telse if ( typeof source === 'string' && (source.indexOf('.') !== -1 ||\n\t\t\t\t  source.indexOf('[') !== -1 || source.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\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\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\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 ( Array.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\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] ] === null) {\n\t\t\t\t\t\t\treturn null;\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse if ( data === undefined || data[ a[i] ] === undefined ) {\n\t\t\t\t\t\t\treturn undefined;\n\t\t\t\t\t\t}\n\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, source );\n\t\t\t};\n\t\t}\n\t\telse {\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[source];\n\t\t\t};\n\t\t}\n\t}\n};\n\n\n\n/**\n * Create a mapping object that allows camel case parameters to be looked up\n * for their Hungarian counterparts. The mapping is stored in a private\n * parameter called `_hungarianMap` which can be accessed on the source object.\n *  @param {object} o\n *  @memberof DataTable#oApi\n */\nfunction _fnHungarianMap ( o )\n{\n\tvar\n\t\thungarian = 'a aa ai ao as b fn i m o s ',\n\t\tmatch,\n\t\tnewKey,\n\t\tmap = {};\n\n\t$.each( o, function (key, val) {\n\t\tmatch = key.match(/^([^A-Z]+?)([A-Z])/);\n\n\t\tif ( match && hungarian.indexOf(match[1]+' ') !== -1 )\n\t\t{\n\t\t\tnewKey = key.replace( match[0], match[2].toLowerCase() );\n\t\t\tmap[ newKey ] = key;\n\n\t\t\tif ( match[1] === 'o' )\n\t\t\t{\n\t\t\t\t_fnHungarianMap( o[key] );\n\t\t\t}\n\t\t}\n\t} );\n\n\to._hungarianMap = map;\n}\n\n\n/**\n * Convert from camel case parameters to Hungarian, based on a Hungarian map\n * created by _fnHungarianMap.\n *  @param {object} src The model object which holds all parameters that can be\n *    mapped.\n *  @param {object} user The object to convert from camel case to Hungarian.\n *  @param {boolean} force When set to `true`, properties which already have a\n *    Hungarian value in the `user` object will be overwritten. Otherwise they\n *    won't be.\n *  @memberof DataTable#oApi\n */\nfunction _fnCamelToHungarian ( src, user, force )\n{\n\tif ( ! src._hungarianMap ) {\n\t\t_fnHungarianMap( src );\n\t}\n\n\tvar hungarianKey;\n\n\t$.each( user, function (key, val) {\n\t\thungarianKey = src._hungarianMap[ key ];\n\n\t\tif ( hungarianKey !== undefined && (force || user[hungarianKey] === undefined) )\n\t\t{\n\t\t\t// For objects, we need to buzz down into the object to copy parameters\n\t\t\tif ( hungarianKey.charAt(0) === 'o' )\n\t\t\t{\n\t\t\t\t// Copy the camelCase options over to the hungarian\n\t\t\t\tif ( ! user[ hungarianKey ] ) {\n\t\t\t\t\tuser[ hungarianKey ] = {};\n\t\t\t\t}\n\t\t\t\t$.extend( true, user[hungarianKey], user[key] );\n\n\t\t\t\t_fnCamelToHungarian( src[hungarianKey], user[hungarianKey], force );\n\t\t\t}\n\t\t\telse {\n\t\t\t\tuser[hungarianKey] = user[ key ];\n\t\t\t}\n\t\t}\n\t} );\n}\n\n\n/**\n * Language compatibility - when certain options are given, and others aren't, we\n * need to duplicate the values over, in order to provide backwards compatibility\n * with older language files.\n *  @param {object} oSettings dataTables settings object\n *  @memberof DataTable#oApi\n */\nfunction _fnLanguageCompat( lang )\n{\n\t// Note the use of the Hungarian notation for the parameters in this method as\n\t// this is called after the mapping of camelCase to Hungarian\n\tvar defaults = DataTable.defaults.oLanguage;\n\n\t// Default mapping\n\tvar defaultDecimal = defaults.sDecimal;\n\tif ( defaultDecimal ) {\n\t\t_addNumericSort( defaultDecimal );\n\t}\n\n\tif ( lang ) {\n\t\tvar zeroRecords = lang.sZeroRecords;\n\n\t\t// Backwards compatibility - if there is no sEmptyTable given, then use the same as\n\t\t// sZeroRecords - assuming that is given.\n\t\tif ( ! lang.sEmptyTable && zeroRecords &&\n\t\t\tdefaults.sEmptyTable === \"No data available in table\" )\n\t\t{\n\t\t\t_fnMap( lang, lang, 'sZeroRecords', 'sEmptyTable' );\n\t\t}\n\n\t\t// Likewise with loading records\n\t\tif ( ! lang.sLoadingRecords && zeroRecords &&\n\t\t\tdefaults.sLoadingRecords === \"Loading...\" )\n\t\t{\n\t\t\t_fnMap( lang, lang, 'sZeroRecords', 'sLoadingRecords' );\n\t\t}\n\n\t\t// Old parameter name of the thousands separator mapped onto the new\n\t\tif ( lang.sInfoThousands ) {\n\t\t\tlang.sThousands = lang.sInfoThousands;\n\t\t}\n\n\t\tvar decimal = lang.sDecimal;\n\t\tif ( decimal && defaultDecimal !== decimal ) {\n\t\t\t_addNumericSort( decimal );\n\t\t}\n\t}\n}\n\n\n/**\n * Map one parameter onto another\n *  @param {object} o Object to map\n *  @param {*} knew The new parameter name\n *  @param {*} old The old parameter name\n */\nvar _fnCompatMap = function ( o, knew, old ) {\n\tif ( o[ knew ] !== undefined ) {\n\t\to[ old ] = o[ knew ];\n\t}\n};\n\n\n/**\n * Provide backwards compatibility for the main DT options. Note that the new\n * options are mapped onto the old parameters, so this is an external interface\n * change only.\n *  @param {object} init Object to map\n */\nfunction _fnCompatOpts ( init )\n{\n\t_fnCompatMap( init, 'ordering',      'bSort' );\n\t_fnCompatMap( init, 'orderMulti',    'bSortMulti' );\n\t_fnCompatMap( init, 'orderClasses',  'bSortClasses' );\n\t_fnCompatMap( init, 'orderCellsTop', 'bSortCellsTop' );\n\t_fnCompatMap( init, 'order',         'aaSorting' );\n\t_fnCompatMap( init, 'orderFixed',    'aaSortingFixed' );\n\t_fnCompatMap( init, 'paging',        'bPaginate' );\n\t_fnCompatMap( init, 'pagingType',    'sPaginationType' );\n\t_fnCompatMap( init, 'pageLength',    'iDisplayLength' );\n\t_fnCompatMap( init, 'searching',     'bFilter' );\n\n\t// Boolean initialisation of x-scrolling\n\tif ( typeof init.sScrollX === 'boolean' ) {\n\t\tinit.sScrollX = init.sScrollX ? '100%' : '';\n\t}\n\tif ( typeof init.scrollX === 'boolean' ) {\n\t\tinit.scrollX = init.scrollX ? '100%' : '';\n\t}\n\n\t// Column search objects are in an array, so it needs to be converted\n\t// element by element\n\tvar searchCols = init.aoSearchCols;\n\n\tif ( searchCols ) {\n\t\tfor ( var i=0, ien=searchCols.length ; i<ien ; i++ ) {\n\t\t\tif ( searchCols[i] ) {\n\t\t\t\t_fnCamelToHungarian( DataTable.models.oSearch, searchCols[i] );\n\t\t\t}\n\t\t}\n\t}\n}\n\n\n/**\n * Provide backwards compatibility for column options. Note that the new options\n * are mapped onto the old parameters, so this is an external interface change\n * only.\n *  @param {object} init Object to map\n */\nfunction _fnCompatCols ( init )\n{\n\t_fnCompatMap( init, 'orderable',     'bSortable' );\n\t_fnCompatMap( init, 'orderData',     'aDataSort' );\n\t_fnCompatMap( init, 'orderSequence', 'asSorting' );\n\t_fnCompatMap( init, 'orderDataType', 'sortDataType' );\n\n\t// orderData can be given as an integer\n\tvar dataSort = init.aDataSort;\n\tif ( typeof dataSort === 'number' && ! Array.isArray( dataSort ) ) {\n\t\tinit.aDataSort = [ dataSort ];\n\t}\n}\n\n\n/**\n * Browser feature detection for capabilities, quirks\n *  @param {object} settings dataTables settings object\n *  @memberof DataTable#oApi\n */\nfunction _fnBrowserDetect( settings )\n{\n\t// We don't need to do this every time DataTables is constructed, the values\n\t// calculated are specific to the browser and OS configuration which we\n\t// don't expect to change between initialisations\n\tif ( ! DataTable.__browser ) {\n\t\tvar browser = {};\n\t\tDataTable.__browser = browser;\n\n\t\t// Scrolling feature / quirks detection\n\t\tvar n = $('<div/>')\n\t\t\t.css( {\n\t\t\t\tposition: 'fixed',\n\t\t\t\ttop: 0,\n\t\t\t\tleft: $(window).scrollLeft()*-1, // allow for scrolling\n\t\t\t\theight: 1,\n\t\t\t\twidth: 1,\n\t\t\t\toverflow: 'hidden'\n\t\t\t} )\n\t\t\t.append(\n\t\t\t\t$('<div/>')\n\t\t\t\t\t.css( {\n\t\t\t\t\t\tposition: 'absolute',\n\t\t\t\t\t\ttop: 1,\n\t\t\t\t\t\tleft: 1,\n\t\t\t\t\t\twidth: 100,\n\t\t\t\t\t\toverflow: 'scroll'\n\t\t\t\t\t} )\n\t\t\t\t\t.append(\n\t\t\t\t\t\t$('<div/>')\n\t\t\t\t\t\t\t.css( {\n\t\t\t\t\t\t\t\twidth: '100%',\n\t\t\t\t\t\t\t\theight: 10\n\t\t\t\t\t\t\t} )\n\t\t\t\t\t)\n\t\t\t)\n\t\t\t.appendTo( 'body' );\n\n\t\tvar outer = n.children();\n\t\tvar inner = outer.children();\n\n\t\t// Numbers below, in order, are:\n\t\t// inner.offsetWidth, inner.clientWidth, outer.offsetWidth, outer.clientWidth\n\t\t//\n\t\t// IE6 XP:                           100 100 100  83\n\t\t// IE7 Vista:                        100 100 100  83\n\t\t// IE 8+ Windows:                     83  83 100  83\n\t\t// Evergreen Windows:                 83  83 100  83\n\t\t// Evergreen Mac with scrollbars:     85  85 100  85\n\t\t// Evergreen Mac without scrollbars: 100 100 100 100\n\n\t\t// Get scrollbar width\n\t\tbrowser.barWidth = outer[0].offsetWidth - outer[0].clientWidth;\n\n\t\t// IE6/7 will oversize a width 100% element inside a scrolling element, to\n\t\t// include the width of the scrollbar, while other browsers ensure the inner\n\t\t// element is contained without forcing scrolling\n\t\tbrowser.bScrollOversize = inner[0].offsetWidth === 100 && outer[0].clientWidth !== 100;\n\n\t\t// In rtl text layout, some browsers (most, but not all) will place the\n\t\t// scrollbar on the left, rather than the right.\n\t\tbrowser.bScrollbarLeft = Math.round( inner.offset().left ) !== 1;\n\n\t\t// IE8- don't provide height and width for getBoundingClientRect\n\t\tbrowser.bBounding = n[0].getBoundingClientRect().width ? true : false;\n\n\t\tn.remove();\n\t}\n\n\t$.extend( settings.oBrowser, DataTable.__browser );\n\tsettings.oScroll.iBarWidth = DataTable.__browser.barWidth;\n}\n\n\n/**\n * Array.prototype reduce[Right] method, used for browsers which don't support\n * JS 1.6. Done this way to reduce code size, since we iterate either way\n *  @param {object} settings dataTables settings object\n *  @memberof DataTable#oApi\n */\nfunction _fnReduce ( that, fn, init, start, end, inc )\n{\n\tvar\n\t\ti = start,\n\t\tvalue,\n\t\tisSet = false;\n\n\tif ( init !== undefined ) {\n\t\tvalue = init;\n\t\tisSet = true;\n\t}\n\n\twhile ( i !== end ) {\n\t\tif ( ! that.hasOwnProperty(i) ) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tvalue = isSet ?\n\t\t\tfn( value, that[i], i, that ) :\n\t\t\tthat[i];\n\n\t\tisSet = true;\n\t\ti += inc;\n\t}\n\n\treturn value;\n}\n\n/**\n * Add a column to the list used for the table with default values\n *  @param {object} oSettings dataTables settings object\n *  @param {node} nTh The th element for this column\n *  @memberof DataTable#oApi\n */\nfunction _fnAddColumn( oSettings, nTh )\n{\n\t// Add column to aoColumns array\n\tvar oDefaults = DataTable.defaults.column;\n\tvar iCol = oSettings.aoColumns.length;\n\tvar oCol = $.extend( {}, DataTable.models.oColumn, oDefaults, {\n\t\t\"nTh\": nTh ? nTh : document.createElement('th'),\n\t\t\"sTitle\":    oDefaults.sTitle    ? oDefaults.sTitle    : nTh ? nTh.innerHTML : '',\n\t\t\"aDataSort\": oDefaults.aDataSort ? oDefaults.aDataSort : [iCol],\n\t\t\"mData\": oDefaults.mData ? oDefaults.mData : iCol,\n\t\tidx: iCol\n\t} );\n\toSettings.aoColumns.push( oCol );\n\n\t// Add search object for column specific search. Note that the `searchCols[ iCol ]`\n\t// passed into extend can be undefined. This allows the user to give a default\n\t// with only some of the parameters defined, and also not give a default\n\tvar searchCols = oSettings.aoPreSearchCols;\n\tsearchCols[ iCol ] = $.extend( {}, DataTable.models.oSearch, searchCols[ iCol ] );\n\n\t// Use the default column options function to initialise classes etc\n\t_fnColumnOptions( oSettings, iCol, $(nTh).data() );\n}\n\n\n/**\n * Apply options for a column\n *  @param {object} oSettings dataTables settings object\n *  @param {int} iCol column index to consider\n *  @param {object} oOptions object with sType, bVisible and bSearchable etc\n *  @memberof DataTable#oApi\n */\nfunction _fnColumnOptions( oSettings, iCol, oOptions )\n{\n\tvar oCol = oSettings.aoColumns[ iCol ];\n\tvar oClasses = oSettings.oClasses;\n\tvar th = $(oCol.nTh);\n\n\t// Try to get width information from the DOM. We can't get it from CSS\n\t// as we'd need to parse the CSS stylesheet. `width` option can override\n\tif ( ! oCol.sWidthOrig ) {\n\t\t// Width attribute\n\t\toCol.sWidthOrig = th.attr('width') || null;\n\n\t\t// Style attribute\n\t\tvar t = (th.attr('style') || '').match(/width:\\s*(\\d+[pxem%]+)/);\n\t\tif ( t ) {\n\t\t\toCol.sWidthOrig = t[1];\n\t\t}\n\t}\n\n\t/* User specified column options */\n\tif ( oOptions !== undefined && oOptions !== null )\n\t{\n\t\t// Backwards compatibility\n\t\t_fnCompatCols( oOptions );\n\n\t\t// Map camel case parameters to their Hungarian counterparts\n\t\t_fnCamelToHungarian( DataTable.defaults.column, oOptions, true );\n\n\t\t/* Backwards compatibility for mDataProp */\n\t\tif ( oOptions.mDataProp !== undefined && !oOptions.mData )\n\t\t{\n\t\t\toOptions.mData = oOptions.mDataProp;\n\t\t}\n\n\t\tif ( oOptions.sType )\n\t\t{\n\t\t\toCol._sManualType = oOptions.sType;\n\t\t}\n\n\t\t// `class` is a reserved word in Javascript, so we need to provide\n\t\t// the ability to use a valid name for the camel case input\n\t\tif ( oOptions.className && ! oOptions.sClass )\n\t\t{\n\t\t\toOptions.sClass = oOptions.className;\n\t\t}\n\t\tif ( oOptions.sClass ) {\n\t\t\tth.addClass( oOptions.sClass );\n\t\t}\n\n\t\tvar origClass = oCol.sClass;\n\n\t\t$.extend( oCol, oOptions );\n\t\t_fnMap( oCol, oOptions, \"sWidth\", \"sWidthOrig\" );\n\n\t\t// Merge class from previously defined classes with this one, rather than just\n\t\t// overwriting it in the extend above\n\t\tif (origClass !== oCol.sClass) {\n\t\t\toCol.sClass = origClass + ' ' + oCol.sClass;\n\t\t}\n\n\t\t/* iDataSort to be applied (backwards compatibility), but aDataSort will take\n\t\t * priority if defined\n\t\t */\n\t\tif ( oOptions.iDataSort !== undefined )\n\t\t{\n\t\t\toCol.aDataSort = [ oOptions.iDataSort ];\n\t\t}\n\t\t_fnMap( oCol, oOptions, \"aDataSort\" );\n\n\t\t// Fall back to the aria-label attribute on the table header if no ariaTitle is\n\t\t// provided.\n\t\tif (! oCol.ariaTitle) {\n\t\t\toCol.ariaTitle = th.attr(\"aria-label\");\n\t\t}\n\t}\n\n\t/* Cache the data get and set functions for speed */\n\tvar mDataSrc = oCol.mData;\n\tvar mData = _fnGetObjectDataFn( mDataSrc );\n\tvar mRender = oCol.mRender ? _fnGetObjectDataFn( oCol.mRender ) : null;\n\n\tvar attrTest = function( src ) {\n\t\treturn typeof src === 'string' && src.indexOf('@') !== -1;\n\t};\n\toCol._bAttrSrc = $.isPlainObject( mDataSrc ) && (\n\t\tattrTest(mDataSrc.sort) || attrTest(mDataSrc.type) || attrTest(mDataSrc.filter)\n\t);\n\toCol._setter = null;\n\n\toCol.fnGetData = function (rowData, type, meta) {\n\t\tvar innerData = mData( rowData, type, undefined, meta );\n\n\t\treturn mRender && type ?\n\t\t\tmRender( innerData, type, rowData, meta ) :\n\t\t\tinnerData;\n\t};\n\toCol.fnSetData = function ( rowData, val, meta ) {\n\t\treturn _fnSetObjectDataFn( mDataSrc )( rowData, val, meta );\n\t};\n\n\t// Indicate if DataTables should read DOM data as an object or array\n\t// Used in _fnGetRowElements\n\tif ( typeof mDataSrc !== 'number' && ! oCol._isArrayHost ) {\n\t\toSettings._rowReadObject = true;\n\t}\n\n\t/* Feature sorting overrides column specific when off */\n\tif ( !oSettings.oFeatures.bSort )\n\t{\n\t\toCol.bSortable = false;\n\t\tth.addClass( oClasses.sSortableNone ); // Have to add class here as order event isn't called\n\t}\n\n\t/* Check that the class assignment is correct for sorting */\n\tvar bAsc = $.inArray('asc', oCol.asSorting) !== -1;\n\tvar bDesc = $.inArray('desc', oCol.asSorting) !== -1;\n\tif ( !oCol.bSortable || (!bAsc && !bDesc) )\n\t{\n\t\toCol.sSortingClass = oClasses.sSortableNone;\n\t\toCol.sSortingClassJUI = \"\";\n\t}\n\telse if ( bAsc && !bDesc )\n\t{\n\t\toCol.sSortingClass = oClasses.sSortableAsc;\n\t\toCol.sSortingClassJUI = oClasses.sSortJUIAscAllowed;\n\t}\n\telse if ( !bAsc && bDesc )\n\t{\n\t\toCol.sSortingClass = oClasses.sSortableDesc;\n\t\toCol.sSortingClassJUI = oClasses.sSortJUIDescAllowed;\n\t}\n\telse\n\t{\n\t\toCol.sSortingClass = oClasses.sSortable;\n\t\toCol.sSortingClassJUI = oClasses.sSortJUI;\n\t}\n}\n\n\n/**\n * Adjust the table column widths for new data. Note: you would probably want to\n * do a redraw after calling this function!\n *  @param {object} settings dataTables settings object\n *  @memberof DataTable#oApi\n */\nfunction _fnAdjustColumnSizing ( settings )\n{\n\t/* Not interested in doing column width calculation if auto-width is disabled */\n\tif ( settings.oFeatures.bAutoWidth !== false )\n\t{\n\t\tvar columns = settings.aoColumns;\n\n\t\t_fnCalculateColumnWidths( settings );\n\t\tfor ( var i=0 , iLen=columns.length ; i<iLen ; i++ )\n\t\t{\n\t\t\tcolumns[i].nTh.style.width = columns[i].sWidth;\n\t\t}\n\t}\n\n\tvar scroll = settings.oScroll;\n\tif ( scroll.sY !== '' || scroll.sX !== '')\n\t{\n\t\t_fnScrollDraw( settings );\n\t}\n\n\t_fnCallbackFire( settings, null, 'column-sizing', [settings] );\n}\n\n\n/**\n * Convert the index of a visible column to the index in the data array (take account\n * of hidden columns)\n *  @param {object} oSettings dataTables settings object\n *  @param {int} iMatch Visible column index to lookup\n *  @returns {int} i the data index\n *  @memberof DataTable#oApi\n */\nfunction _fnVisibleToColumnIndex( oSettings, iMatch )\n{\n\tvar aiVis = _fnGetColumns( oSettings, 'bVisible' );\n\n\treturn typeof aiVis[iMatch] === 'number' ?\n\t\taiVis[iMatch] :\n\t\tnull;\n}\n\n\n/**\n * Convert the index of an index in the data array and convert it to the visible\n *   column index (take account of hidden columns)\n *  @param {int} iMatch Column index to lookup\n *  @param {object} oSettings dataTables settings object\n *  @returns {int} i the data index\n *  @memberof DataTable#oApi\n */\nfunction _fnColumnIndexToVisible( oSettings, iMatch )\n{\n\tvar aiVis = _fnGetColumns( oSettings, 'bVisible' );\n\tvar iPos = $.inArray( iMatch, aiVis );\n\n\treturn iPos !== -1 ? iPos : null;\n}\n\n\n/**\n * Get the number of visible columns\n *  @param {object} oSettings dataTables settings object\n *  @returns {int} i the number of visible columns\n *  @memberof DataTable#oApi\n */\nfunction _fnVisbleColumns( oSettings )\n{\n\tvar vis = 0;\n\n\t// No reduce in IE8, use a loop for now\n\t$.each( oSettings.aoColumns, function ( i, col ) {\n\t\tif ( col.bVisible && $(col.nTh).css('display') !== 'none' ) {\n\t\t\tvis++;\n\t\t}\n\t} );\n\n\treturn vis;\n}\n\n\n/**\n * Get an array of column indexes that match a given property\n *  @param {object} oSettings dataTables settings object\n *  @param {string} sParam Parameter in aoColumns to look for - typically\n *    bVisible or bSearchable\n *  @returns {array} Array of indexes with matched properties\n *  @memberof DataTable#oApi\n */\nfunction _fnGetColumns( oSettings, sParam )\n{\n\tvar a = [];\n\n\t$.map( oSettings.aoColumns, function(val, i) {\n\t\tif ( val[sParam] ) {\n\t\t\ta.push( i );\n\t\t}\n\t} );\n\n\treturn a;\n}\n\n\n/**\n * Calculate the 'type' of a column\n *  @param {object} settings dataTables settings object\n *  @memberof DataTable#oApi\n */\nfunction _fnColumnTypes ( settings )\n{\n\tvar columns = settings.aoColumns;\n\tvar data = settings.aoData;\n\tvar types = DataTable.ext.type.detect;\n\tvar i, ien, j, jen, k, ken;\n\tvar col, cell, detectedType, cache;\n\n\t// For each column, spin over the \n\tfor ( i=0, ien=columns.length ; i<ien ; i++ ) {\n\t\tcol = columns[i];\n\t\tcache = [];\n\n\t\tif ( ! col.sType && col._sManualType ) {\n\t\t\tcol.sType = col._sManualType;\n\t\t}\n\t\telse if ( ! col.sType ) {\n\t\t\tfor ( j=0, jen=types.length ; j<jen ; j++ ) {\n\t\t\t\tfor ( k=0, ken=data.length ; k<ken ; k++ ) {\n\t\t\t\t\t// Use a cache array so we only need to get the type data\n\t\t\t\t\t// from the formatter once (when using multiple detectors)\n\t\t\t\t\tif ( cache[k] === undefined ) {\n\t\t\t\t\t\tcache[k] = _fnGetCellData( settings, k, i, 'type' );\n\t\t\t\t\t}\n\n\t\t\t\t\tdetectedType = types[j]( cache[k], settings );\n\n\t\t\t\t\t// If null, then this type can't apply to this column, so\n\t\t\t\t\t// rather than testing all cells, break out. There is an\n\t\t\t\t\t// exception for the last type which is `html`. We need to\n\t\t\t\t\t// scan all rows since it is possible to mix string and HTML\n\t\t\t\t\t// types\n\t\t\t\t\tif ( ! detectedType && j !== types.length-1 ) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Only a single match is needed for html type since it is\n\t\t\t\t\t// bottom of the pile and very similar to string - but it\n\t\t\t\t\t// must not be empty\n\t\t\t\t\tif ( detectedType === 'html' && ! _empty(cache[k]) ) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Type is valid for all data points in the column - use this\n\t\t\t\t// type\n\t\t\t\tif ( detectedType ) {\n\t\t\t\t\tcol.sType = detectedType;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Fall back - if no type was detected, always use string\n\t\t\tif ( ! col.sType ) {\n\t\t\t\tcol.sType = 'string';\n\t\t\t}\n\t\t}\n\t}\n}\n\n\n/**\n * Take the column definitions and static columns arrays and calculate how\n * they relate to column indexes. The callback function will then apply the\n * definition found for a column to a suitable configuration object.\n *  @param {object} oSettings dataTables settings object\n *  @param {array} aoColDefs The aoColumnDefs array that is to be applied\n *  @param {array} aoCols The aoColumns array that defines columns individually\n *  @param {function} fn Callback function - takes two parameters, the calculated\n *    column index and the definition for that column.\n *  @memberof DataTable#oApi\n */\nfunction _fnApplyColumnDefs( oSettings, aoColDefs, aoCols, fn )\n{\n\tvar i, iLen, j, jLen, k, kLen, def;\n\tvar columns = oSettings.aoColumns;\n\n\t// Column definitions with aTargets\n\tif ( aoColDefs )\n\t{\n\t\t/* Loop over the definitions array - loop in reverse so first instance has priority */\n\t\tfor ( i=aoColDefs.length-1 ; i>=0 ; i-- )\n\t\t{\n\t\t\tdef = aoColDefs[i];\n\n\t\t\t/* Each definition can target multiple columns, as it is an array */\n\t\t\tvar aTargets = def.target !== undefined\n\t\t\t\t? def.target\n\t\t\t\t: def.targets !== undefined\n\t\t\t\t\t? def.targets\n\t\t\t\t\t: def.aTargets;\n\n\t\t\tif ( ! Array.isArray( aTargets ) )\n\t\t\t{\n\t\t\t\taTargets = [ aTargets ];\n\t\t\t}\n\n\t\t\tfor ( j=0, jLen=aTargets.length ; j<jLen ; j++ )\n\t\t\t{\n\t\t\t\tif ( typeof aTargets[j] === 'number' && aTargets[j] >= 0 )\n\t\t\t\t{\n\t\t\t\t\t/* Add columns that we don't yet know about */\n\t\t\t\t\twhile( columns.length <= aTargets[j] )\n\t\t\t\t\t{\n\t\t\t\t\t\t_fnAddColumn( oSettings );\n\t\t\t\t\t}\n\n\t\t\t\t\t/* Integer, basic index */\n\t\t\t\t\tfn( aTargets[j], def );\n\t\t\t\t}\n\t\t\t\telse if ( typeof aTargets[j] === 'number' && aTargets[j] < 0 )\n\t\t\t\t{\n\t\t\t\t\t/* Negative integer, right to left column counting */\n\t\t\t\t\tfn( columns.length+aTargets[j], def );\n\t\t\t\t}\n\t\t\t\telse if ( typeof aTargets[j] === 'string' )\n\t\t\t\t{\n\t\t\t\t\t/* Class name matching on TH element */\n\t\t\t\t\tfor ( k=0, kLen=columns.length ; k<kLen ; k++ )\n\t\t\t\t\t{\n\t\t\t\t\t\tif ( aTargets[j] == \"_all\" ||\n\t\t\t\t\t\t     $(columns[k].nTh).hasClass( aTargets[j] ) )\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tfn( k, def );\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\n\t// Statically defined columns array\n\tif ( aoCols )\n\t{\n\t\tfor ( i=0, iLen=aoCols.length ; i<iLen ; i++ )\n\t\t{\n\t\t\tfn( i, aoCols[i] );\n\t\t}\n\t}\n}\n\n/**\n * Add a data array to the table, creating DOM node etc. This is the parallel to\n * _fnGatherData, but for adding rows from a Javascript source, rather than a\n * DOM source.\n *  @param {object} oSettings dataTables settings object\n *  @param {array} aData data array to be added\n *  @param {node} [nTr] TR element to add to the table - optional. If not given,\n *    DataTables will create a row automatically\n *  @param {array} [anTds] Array of TD|TH elements for the row - must be given\n *    if nTr is.\n *  @returns {int} >=0 if successful (index of new aoData entry), -1 if failed\n *  @memberof DataTable#oApi\n */\nfunction _fnAddData ( oSettings, aDataIn, nTr, anTds )\n{\n\t/* Create the object for storing information about this new row */\n\tvar iRow = oSettings.aoData.length;\n\tvar oData = $.extend( true, {}, DataTable.models.oRow, {\n\t\tsrc: nTr ? 'dom' : 'data',\n\t\tidx: iRow\n\t} );\n\n\toData._aData = aDataIn;\n\toSettings.aoData.push( oData );\n\n\t/* Create the cells */\n\tvar nTd, sThisType;\n\tvar columns = oSettings.aoColumns;\n\n\t// Invalidate the column types as the new data needs to be revalidated\n\tfor ( var i=0, iLen=columns.length ; i<iLen ; i++ )\n\t{\n\t\tcolumns[i].sType = null;\n\t}\n\n\t/* Add to the display array */\n\toSettings.aiDisplayMaster.push( iRow );\n\n\tvar id = oSettings.rowIdFn( aDataIn );\n\tif ( id !== undefined ) {\n\t\toSettings.aIds[ id ] = oData;\n\t}\n\n\t/* Create the DOM information, or register it if already present */\n\tif ( nTr || ! oSettings.oFeatures.bDeferRender )\n\t{\n\t\t_fnCreateTr( oSettings, iRow, nTr, anTds );\n\t}\n\n\treturn iRow;\n}\n\n\n/**\n * Add one or more TR elements to the table. Generally we'd expect to\n * use this for reading data from a DOM sourced table, but it could be\n * used for an TR element. Note that if a TR is given, it is used (i.e.\n * it is not cloned).\n *  @param {object} settings dataTables settings object\n *  @param {array|node|jQuery} trs The TR element(s) to add to the table\n *  @returns {array} Array of indexes for the added rows\n *  @memberof DataTable#oApi\n */\nfunction _fnAddTr( settings, trs )\n{\n\tvar row;\n\n\t// Allow an individual node to be passed in\n\tif ( ! (trs instanceof $) ) {\n\t\ttrs = $(trs);\n\t}\n\n\treturn trs.map( function (i, el) {\n\t\trow = _fnGetRowElements( settings, el );\n\t\treturn _fnAddData( settings, row.data, el, row.cells );\n\t} );\n}\n\n\n/**\n * Take a TR element and convert it to an index in aoData\n *  @param {object} oSettings dataTables settings object\n *  @param {node} n the TR element to find\n *  @returns {int} index if the node is found, null if not\n *  @memberof DataTable#oApi\n */\nfunction _fnNodeToDataIndex( oSettings, n )\n{\n\treturn (n._DT_RowIndex!==undefined) ? n._DT_RowIndex : null;\n}\n\n\n/**\n * Take a TD element and convert it into a column data index (not the visible index)\n *  @param {object} oSettings dataTables settings object\n *  @param {int} iRow The row number the TD/TH can be found in\n *  @param {node} n The TD/TH element to find\n *  @returns {int} index if the node is found, -1 if not\n *  @memberof DataTable#oApi\n */\nfunction _fnNodeToColumnIndex( oSettings, iRow, n )\n{\n\treturn $.inArray( n, oSettings.aoData[ iRow ].anCells );\n}\n\n\n/**\n * Get the data for a given cell from the internal cache, taking into account data mapping\n *  @param {object} settings dataTables settings object\n *  @param {int} rowIdx aoData row id\n *  @param {int} colIdx Column index\n *  @param {string} type data get type ('display', 'type' 'filter|search' 'sort|order')\n *  @returns {*} Cell data\n *  @memberof DataTable#oApi\n */\nfunction _fnGetCellData( settings, rowIdx, colIdx, type )\n{\n\tif (type === 'search') {\n\t\ttype = 'filter';\n\t}\n\telse if (type === 'order') {\n\t\ttype = 'sort';\n\t}\n\n\tvar draw           = settings.iDraw;\n\tvar col            = settings.aoColumns[colIdx];\n\tvar rowData        = settings.aoData[rowIdx]._aData;\n\tvar defaultContent = col.sDefaultContent;\n\tvar cellData       = col.fnGetData( rowData, type, {\n\t\tsettings: settings,\n\t\trow:      rowIdx,\n\t\tcol:      colIdx\n\t} );\n\n\tif ( cellData === undefined ) {\n\t\tif ( settings.iDrawError != draw && defaultContent === null ) {\n\t\t\t_fnLog( settings, 0, \"Requested unknown parameter \"+\n\t\t\t\t(typeof col.mData=='function' ? '{function}' : \"'\"+col.mData+\"'\")+\n\t\t\t\t\" for row \"+rowIdx+\", column \"+colIdx, 4 );\n\t\t\tsettings.iDrawError = draw;\n\t\t}\n\t\treturn defaultContent;\n\t}\n\n\t// When the data source is null and a specific data type is requested (i.e.\n\t// not the original data), we can use default column data\n\tif ( (cellData === rowData || cellData === null) && defaultContent !== null && type !== undefined ) {\n\t\tcellData = defaultContent;\n\t}\n\telse if ( typeof cellData === 'function' ) {\n\t\t// If the data source is a function, then we run it and use the return,\n\t\t// executing in the scope of the data object (for instances)\n\t\treturn cellData.call( rowData );\n\t}\n\n\tif ( cellData === null && type === 'display' ) {\n\t\treturn '';\n\t}\n\n\tif ( type === 'filter' ) {\n\t\tvar fomatters = DataTable.ext.type.search;\n\n\t\tif ( fomatters[ col.sType ] ) {\n\t\t\tcellData = fomatters[ col.sType ]( cellData );\n\t\t}\n\t}\n\n\treturn cellData;\n}\n\n\n/**\n * Set the value for a specific cell, into the internal data cache\n *  @param {object} settings dataTables settings object\n *  @param {int} rowIdx aoData row id\n *  @param {int} colIdx Column index\n *  @param {*} val Value to set\n *  @memberof DataTable#oApi\n */\nfunction _fnSetCellData( settings, rowIdx, colIdx, val )\n{\n\tvar col     = settings.aoColumns[colIdx];\n\tvar rowData = settings.aoData[rowIdx]._aData;\n\n\tcol.fnSetData( rowData, val, {\n\t\tsettings: settings,\n\t\trow:      rowIdx,\n\t\tcol:      colIdx\n\t}  );\n}\n\n\n// Private variable that is used to match action syntax in the data property object\nvar __reArray = /\\[.*?\\]$/;\nvar __reFn = /\\(\\)$/;\n\n/**\n * Split string on periods, taking into account escaped periods\n * @param  {string} str String to split\n * @return {array} Split string\n */\nfunction _fnSplitObjNotation( str )\n{\n\treturn $.map( str.match(/(\\\\.|[^\\.])+/g) || [''], function ( s ) {\n\t\treturn s.replace(/\\\\\\./g, '.');\n\t} );\n}\n\n\n/**\n * Return a function that can be used to get data from a source object, taking\n * into account the ability to use nested objects as a source\n *  @param {string|int|function} mSource The data source for the object\n *  @returns {function} Data get function\n *  @memberof DataTable#oApi\n */\nvar _fnGetObjectDataFn = DataTable.util.get;\n\n\n/**\n * Return a function that can be used to set data from a source object, taking\n * into account the ability to use nested objects as a source\n *  @param {string|int|function} mSource The data source for the object\n *  @returns {function} Data set function\n *  @memberof DataTable#oApi\n */\nvar _fnSetObjectDataFn = DataTable.util.set;\n\n\n/**\n * Return an array with the full table data\n *  @param {object} oSettings dataTables settings object\n *  @returns array {array} aData Master data array\n *  @memberof DataTable#oApi\n */\nfunction _fnGetDataMaster ( settings )\n{\n\treturn _pluck( settings.aoData, '_aData' );\n}\n\n\n/**\n * Nuke the table\n *  @param {object} oSettings dataTables settings object\n *  @memberof DataTable#oApi\n */\nfunction _fnClearTable( settings )\n{\n\tsettings.aoData.length = 0;\n\tsettings.aiDisplayMaster.length = 0;\n\tsettings.aiDisplay.length = 0;\n\tsettings.aIds = {};\n}\n\n\n /**\n * Take an array of integers (index array) and remove a target integer (value - not\n * the key!)\n *  @param {array} a Index array to target\n *  @param {int} iTarget value to find\n *  @memberof DataTable#oApi\n */\nfunction _fnDeleteIndex( a, iTarget, splice )\n{\n\tvar iTargetIndex = -1;\n\n\tfor ( var i=0, iLen=a.length ; i<iLen ; i++ )\n\t{\n\t\tif ( a[i] == iTarget )\n\t\t{\n\t\t\tiTargetIndex = i;\n\t\t}\n\t\telse if ( a[i] > iTarget )\n\t\t{\n\t\t\ta[i]--;\n\t\t}\n\t}\n\n\tif ( iTargetIndex != -1 && splice === undefined )\n\t{\n\t\ta.splice( iTargetIndex, 1 );\n\t}\n}\n\n\n/**\n * Mark cached data as invalid such that a re-read of the data will occur when\n * the cached data is next requested. Also update from the data source object.\n *\n * @param {object} settings DataTables settings object\n * @param {int}    rowIdx   Row index to invalidate\n * @param {string} [src]    Source to invalidate from: undefined, 'auto', 'dom'\n *     or 'data'\n * @param {int}    [colIdx] Column index to invalidate. If undefined the whole\n *     row will be invalidated\n * @memberof DataTable#oApi\n *\n * @todo For the modularisation of v1.11 this will need to become a callback, so\n *   the sort and filter methods can subscribe to it. That will required\n *   initialisation options for sorting, which is why it is not already baked in\n */\nfunction _fnInvalidate( settings, rowIdx, src, colIdx )\n{\n\tvar row = settings.aoData[ rowIdx ];\n\tvar i, ien;\n\tvar cellWrite = function ( cell, col ) {\n\t\t// This is very frustrating, but in IE if you just write directly\n\t\t// to innerHTML, and elements that are overwritten are GC'ed,\n\t\t// even if there is a reference to them elsewhere\n\t\twhile ( cell.childNodes.length ) {\n\t\t\tcell.removeChild( cell.firstChild );\n\t\t}\n\n\t\tcell.innerHTML = _fnGetCellData( settings, rowIdx, col, 'display' );\n\t};\n\n\t// Are we reading last data from DOM or the data object?\n\tif ( src === 'dom' || ((! src || src === 'auto') && row.src === 'dom') ) {\n\t\t// Read the data from the DOM\n\t\trow._aData = _fnGetRowElements(\n\t\t\t\tsettings, row, colIdx, colIdx === undefined ? undefined : row._aData\n\t\t\t)\n\t\t\t.data;\n\t}\n\telse {\n\t\t// Reading from data object, update the DOM\n\t\tvar cells = row.anCells;\n\n\t\tif ( cells ) {\n\t\t\tif ( colIdx !== undefined ) {\n\t\t\t\tcellWrite( cells[colIdx], colIdx );\n\t\t\t}\n\t\t\telse {\n\t\t\t\tfor ( i=0, ien=cells.length ; i<ien ; i++ ) {\n\t\t\t\t\tcellWrite( cells[i], i );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// For both row and cell invalidation, the cached data for sorting and\n\t// filtering is nulled out\n\trow._aSortData = null;\n\trow._aFilterData = null;\n\n\t// Invalidate the type for a specific column (if given) or all columns since\n\t// the data might have changed\n\tvar cols = settings.aoColumns;\n\tif ( colIdx !== undefined ) {\n\t\tcols[ colIdx ].sType = null;\n\t}\n\telse {\n\t\tfor ( i=0, ien=cols.length ; i<ien ; i++ ) {\n\t\t\tcols[i].sType = null;\n\t\t}\n\n\t\t// Update DataTables special `DT_*` attributes for the row\n\t\t_fnRowAttributes( settings, row );\n\t}\n}\n\n\n/**\n * Build a data source object from an HTML row, reading the contents of the\n * cells that are in the row.\n *\n * @param {object} settings DataTables settings object\n * @param {node|object} TR element from which to read data or existing row\n *   object from which to re-read the data from the cells\n * @param {int} [colIdx] Optional column index\n * @param {array|object} [d] Data source object. If `colIdx` is given then this\n *   parameter should also be given and will be used to write the data into.\n *   Only the column in question will be written\n * @returns {object} Object with two parameters: `data` the data read, in\n *   document order, and `cells` and array of nodes (they can be useful to the\n *   caller, so rather than needing a second traversal to get them, just return\n *   them from here).\n * @memberof DataTable#oApi\n */\nfunction _fnGetRowElements( settings, row, colIdx, d )\n{\n\tvar\n\t\ttds = [],\n\t\ttd = row.firstChild,\n\t\tname, col, o, i=0, contents,\n\t\tcolumns = settings.aoColumns,\n\t\tobjectRead = settings._rowReadObject;\n\n\t// Allow the data object to be passed in, or construct\n\td = d !== undefined ?\n\t\td :\n\t\tobjectRead ?\n\t\t\t{} :\n\t\t\t[];\n\n\tvar attr = function ( str, td  ) {\n\t\tif ( typeof str === 'string' ) {\n\t\t\tvar idx = str.indexOf('@');\n\n\t\t\tif ( idx !== -1 ) {\n\t\t\t\tvar attr = str.substring( idx+1 );\n\t\t\t\tvar setter = _fnSetObjectDataFn( str );\n\t\t\t\tsetter( d, td.getAttribute( attr ) );\n\t\t\t}\n\t\t}\n\t};\n\n\t// Read data from a cell and store into the data object\n\tvar cellProcess = function ( cell ) {\n\t\tif ( colIdx === undefined || colIdx === i ) {\n\t\t\tcol = columns[i];\n\t\t\tcontents = (cell.innerHTML).trim();\n\n\t\t\tif ( col && col._bAttrSrc ) {\n\t\t\t\tvar setter = _fnSetObjectDataFn( col.mData._ );\n\t\t\t\tsetter( d, contents );\n\n\t\t\t\tattr( col.mData.sort, cell );\n\t\t\t\tattr( col.mData.type, cell );\n\t\t\t\tattr( col.mData.filter, cell );\n\t\t\t}\n\t\t\telse {\n\t\t\t\t// Depending on the `data` option for the columns the data can\n\t\t\t\t// be read to either an object or an array.\n\t\t\t\tif ( objectRead ) {\n\t\t\t\t\tif ( ! col._setter ) {\n\t\t\t\t\t\t// Cache the setter function\n\t\t\t\t\t\tcol._setter = _fnSetObjectDataFn( col.mData );\n\t\t\t\t\t}\n\t\t\t\t\tcol._setter( d, contents );\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\td[i] = contents;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\ti++;\n\t};\n\n\tif ( td ) {\n\t\t// `tr` element was passed in\n\t\twhile ( td ) {\n\t\t\tname = td.nodeName.toUpperCase();\n\n\t\t\tif ( name == \"TD\" || name == \"TH\" ) {\n\t\t\t\tcellProcess( td );\n\t\t\t\ttds.push( td );\n\t\t\t}\n\n\t\t\ttd = td.nextSibling;\n\t\t}\n\t}\n\telse {\n\t\t// Existing row object passed in\n\t\ttds = row.anCells;\n\n\t\tfor ( var j=0, jen=tds.length ; j<jen ; j++ ) {\n\t\t\tcellProcess( tds[j] );\n\t\t}\n\t}\n\n\t// Read the ID from the DOM if present\n\tvar rowNode = row.firstChild ? row : row.nTr;\n\n\tif ( rowNode ) {\n\t\tvar id = rowNode.getAttribute( 'id' );\n\n\t\tif ( id ) {\n\t\t\t_fnSetObjectDataFn( settings.rowId )( d, id );\n\t\t}\n\t}\n\n\treturn {\n\t\tdata: d,\n\t\tcells: tds\n\t};\n}\n/**\n * Create a new TR element (and it's TD children) for a row\n *  @param {object} oSettings dataTables settings object\n *  @param {int} iRow Row to consider\n *  @param {node} [nTrIn] TR element to add to the table - optional. If not given,\n *    DataTables will create a row automatically\n *  @param {array} [anTds] Array of TD|TH elements for the row - must be given\n *    if nTr is.\n *  @memberof DataTable#oApi\n */\nfunction _fnCreateTr ( oSettings, iRow, nTrIn, anTds )\n{\n\tvar\n\t\trow = oSettings.aoData[iRow],\n\t\trowData = row._aData,\n\t\tcells = [],\n\t\tnTr, nTd, oCol,\n\t\ti, iLen, create;\n\n\tif ( row.nTr === null )\n\t{\n\t\tnTr = nTrIn || document.createElement('tr');\n\n\t\trow.nTr = nTr;\n\t\trow.anCells = cells;\n\n\t\t/* Use a private property on the node to allow reserve mapping from the node\n\t\t * to the aoData array for fast look up\n\t\t */\n\t\tnTr._DT_RowIndex = iRow;\n\n\t\t/* Special parameters can be given by the data source to be used on the row */\n\t\t_fnRowAttributes( oSettings, row );\n\n\t\t/* Process each column */\n\t\tfor ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )\n\t\t{\n\t\t\toCol = oSettings.aoColumns[i];\n\t\t\tcreate = nTrIn ? false : true;\n\n\t\t\tnTd = create ? document.createElement( oCol.sCellType ) : anTds[i];\n\n\t\t\tif (! nTd) {\n\t\t\t\t_fnLog( oSettings, 0, 'Incorrect column count', 18 );\n\t\t\t}\n\n\t\t\tnTd._DT_CellIndex = {\n\t\t\t\trow: iRow,\n\t\t\t\tcolumn: i\n\t\t\t};\n\t\t\t\n\t\t\tcells.push( nTd );\n\n\t\t\t// Need to create the HTML if new, or if a rendering function is defined\n\t\t\tif ( create || ((oCol.mRender || oCol.mData !== i) &&\n\t\t\t\t (!$.isPlainObject(oCol.mData) || oCol.mData._ !== i+'.display')\n\t\t\t)) {\n\t\t\t\tnTd.innerHTML = _fnGetCellData( oSettings, iRow, i, 'display' );\n\t\t\t}\n\n\t\t\t/* Add user defined class */\n\t\t\tif ( oCol.sClass )\n\t\t\t{\n\t\t\t\tnTd.className += ' '+oCol.sClass;\n\t\t\t}\n\n\t\t\t// Visibility - add or remove as required\n\t\t\tif ( oCol.bVisible && ! nTrIn )\n\t\t\t{\n\t\t\t\tnTr.appendChild( nTd );\n\t\t\t}\n\t\t\telse if ( ! oCol.bVisible && nTrIn )\n\t\t\t{\n\t\t\t\tnTd.parentNode.removeChild( nTd );\n\t\t\t}\n\n\t\t\tif ( oCol.fnCreatedCell )\n\t\t\t{\n\t\t\t\toCol.fnCreatedCell.call( oSettings.oInstance,\n\t\t\t\t\tnTd, _fnGetCellData( oSettings, iRow, i ), rowData, iRow, i\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\n\t\t_fnCallbackFire( oSettings, 'aoRowCreatedCallback', null, [nTr, rowData, iRow, cells] );\n\t}\n}\n\n\n/**\n * Add attributes to a row based on the special `DT_*` parameters in a data\n * source object.\n *  @param {object} settings DataTables settings object\n *  @param {object} DataTables row object for the row to be modified\n *  @memberof DataTable#oApi\n */\nfunction _fnRowAttributes( settings, row )\n{\n\tvar tr = row.nTr;\n\tvar data = row._aData;\n\n\tif ( tr ) {\n\t\tvar id = settings.rowIdFn( data );\n\n\t\tif ( id ) {\n\t\t\ttr.id = id;\n\t\t}\n\n\t\tif ( data.DT_RowClass ) {\n\t\t\t// Remove any classes added by DT_RowClass before\n\t\t\tvar a = data.DT_RowClass.split(' ');\n\t\t\trow.__rowc = row.__rowc ?\n\t\t\t\t_unique( row.__rowc.concat( a ) ) :\n\t\t\t\ta;\n\n\t\t\t$(tr)\n\t\t\t\t.removeClass( row.__rowc.join(' ') )\n\t\t\t\t.addClass( data.DT_RowClass );\n\t\t}\n\n\t\tif ( data.DT_RowAttr ) {\n\t\t\t$(tr).attr( data.DT_RowAttr );\n\t\t}\n\n\t\tif ( data.DT_RowData ) {\n\t\t\t$(tr).data( data.DT_RowData );\n\t\t}\n\t}\n}\n\n\n/**\n * Create the HTML header for the table\n *  @param {object} oSettings dataTables settings object\n *  @memberof DataTable#oApi\n */\nfunction _fnBuildHead( oSettings )\n{\n\tvar i, ien, cell, row, column;\n\tvar thead = oSettings.nTHead;\n\tvar tfoot = oSettings.nTFoot;\n\tvar createHeader = $('th, td', thead).length === 0;\n\tvar classes = oSettings.oClasses;\n\tvar columns = oSettings.aoColumns;\n\n\tif ( createHeader ) {\n\t\trow = $('<tr/>').appendTo( thead );\n\t}\n\n\tfor ( i=0, ien=columns.length ; i<ien ; i++ ) {\n\t\tcolumn = columns[i];\n\t\tcell = $( column.nTh ).addClass( column.sClass );\n\n\t\tif ( createHeader ) {\n\t\t\tcell.appendTo( row );\n\t\t}\n\n\t\t// 1.11 move into sorting\n\t\tif ( oSettings.oFeatures.bSort ) {\n\t\t\tcell.addClass( column.sSortingClass );\n\n\t\t\tif ( column.bSortable !== false ) {\n\t\t\t\tcell\n\t\t\t\t\t.attr( 'tabindex', oSettings.iTabIndex )\n\t\t\t\t\t.attr( 'aria-controls', oSettings.sTableId );\n\n\t\t\t\t_fnSortAttachListener( oSettings, column.nTh, i );\n\t\t\t}\n\t\t}\n\n\t\tif ( column.sTitle != cell[0].innerHTML ) {\n\t\t\tcell.html( column.sTitle );\n\t\t}\n\n\t\t_fnRenderer( oSettings, 'header' )(\n\t\t\toSettings, cell, column, classes\n\t\t);\n\t}\n\n\tif ( createHeader ) {\n\t\t_fnDetectHeader( oSettings.aoHeader, thead );\n\t}\n\n\t/* Deal with the footer - add classes if required */\n\t$(thead).children('tr').children('th, td').addClass( classes.sHeaderTH );\n\t$(tfoot).children('tr').children('th, td').addClass( classes.sFooterTH );\n\n\t// Cache the footer cells. Note that we only take the cells from the first\n\t// row in the footer. If there is more than one row the user wants to\n\t// interact with, they need to use the table().foot() method. Note also this\n\t// allows cells to be used for multiple columns using colspan\n\tif ( tfoot !== null ) {\n\t\tvar cells = oSettings.aoFooter[0];\n\n\t\tfor ( i=0, ien=cells.length ; i<ien ; i++ ) {\n\t\t\tcolumn = columns[i];\n\n\t\t\tif (column) {\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\telse {\n\t\t\t\t_fnLog( oSettings, 0, 'Incorrect column count', 18 );\n\t\t\t}\n\t\t}\n\t}\n}\n\n\n/**\n * Draw the header (or footer) element based on the column visibility states. The\n * methodology here is to use the layout array from _fnDetectHeader, modified for\n * the instantaneous column visibility, to construct the new layout. The grid is\n * traversed over cell at a time in a rows x columns grid fashion, although each\n * cell insert can cover multiple elements in the grid - which is tracks using the\n * aApplied array. Cell inserts in the grid will only occur where there isn't\n * already a cell in that position.\n *  @param {object} oSettings dataTables settings object\n *  @param array {objects} aoSource Layout array from _fnDetectHeader\n *  @param {boolean} [bIncludeHidden=false] If true then include the hidden columns in the calc,\n *  @memberof DataTable#oApi\n */\nfunction _fnDrawHead( oSettings, aoSource, bIncludeHidden )\n{\n\tvar i, iLen, j, jLen, k, kLen, n, nLocalTr;\n\tvar aoLocal = [];\n\tvar aApplied = [];\n\tvar iColumns = oSettings.aoColumns.length;\n\tvar iRowspan, iColspan;\n\n\tif ( ! aoSource )\n\t{\n\t\treturn;\n\t}\n\n\tif (  bIncludeHidden === undefined )\n\t{\n\t\tbIncludeHidden = false;\n\t}\n\n\t/* Make a copy of the master layout array, but without the visible columns in it */\n\tfor ( i=0, iLen=aoSource.length ; i<iLen ; i++ )\n\t{\n\t\taoLocal[i] = aoSource[i].slice();\n\t\taoLocal[i].nTr = aoSource[i].nTr;\n\n\t\t/* Remove any columns which are currently hidden */\n\t\tfor ( j=iColumns-1 ; j>=0 ; j-- )\n\t\t{\n\t\t\tif ( !oSettings.aoColumns[j].bVisible && !bIncludeHidden )\n\t\t\t{\n\t\t\t\taoLocal[i].splice( j, 1 );\n\t\t\t}\n\t\t}\n\n\t\t/* Prep the applied array - it needs an element for each row */\n\t\taApplied.push( [] );\n\t}\n\n\tfor ( i=0, iLen=aoLocal.length ; i<iLen ; i++ )\n\t{\n\t\tnLocalTr = aoLocal[i].nTr;\n\n\t\t/* All cells are going to be replaced, so empty out the row */\n\t\tif ( nLocalTr )\n\t\t{\n\t\t\twhile( (n = nLocalTr.firstChild) )\n\t\t\t{\n\t\t\t\tnLocalTr.removeChild( n );\n\t\t\t}\n\t\t}\n\n\t\tfor ( j=0, jLen=aoLocal[i].length ; j<jLen ; j++ )\n\t\t{\n\t\t\tiRowspan = 1;\n\t\t\tiColspan = 1;\n\n\t\t\t/* Check to see if there is already a cell (row/colspan) covering our target\n\t\t\t * insert point. If there is, then there is nothing to do.\n\t\t\t */\n\t\t\tif ( aApplied[i][j] === undefined )\n\t\t\t{\n\t\t\t\tnLocalTr.appendChild( aoLocal[i][j].cell );\n\t\t\t\taApplied[i][j] = 1;\n\n\t\t\t\t/* Expand the cell to cover as many rows as needed */\n\t\t\t\twhile ( aoLocal[i+iRowspan] !== undefined &&\n\t\t\t\t        aoLocal[i][j].cell == aoLocal[i+iRowspan][j].cell )\n\t\t\t\t{\n\t\t\t\t\taApplied[i+iRowspan][j] = 1;\n\t\t\t\t\tiRowspan++;\n\t\t\t\t}\n\n\t\t\t\t/* Expand the cell to cover as many columns as needed */\n\t\t\t\twhile ( aoLocal[i][j+iColspan] !== undefined &&\n\t\t\t\t        aoLocal[i][j].cell == aoLocal[i][j+iColspan].cell )\n\t\t\t\t{\n\t\t\t\t\t/* Must update the applied array over the rows for the columns */\n\t\t\t\t\tfor ( k=0 ; k<iRowspan ; k++ )\n\t\t\t\t\t{\n\t\t\t\t\t\taApplied[i+k][j+iColspan] = 1;\n\t\t\t\t\t}\n\t\t\t\t\tiColspan++;\n\t\t\t\t}\n\n\t\t\t\t/* Do the actual expansion in the DOM */\n\t\t\t\t$(aoLocal[i][j].cell)\n\t\t\t\t\t.attr('rowspan', iRowspan)\n\t\t\t\t\t.attr('colspan', iColspan);\n\t\t\t}\n\t\t}\n\t}\n}\n\n\n/**\n * Insert the required TR nodes into the table for display\n *  @param {object} oSettings dataTables settings object\n *  @param ajaxComplete true after ajax call to complete rendering\n *  @memberof DataTable#oApi\n */\nfunction _fnDraw( oSettings, ajaxComplete )\n{\n\t// Allow for state saving and a custom start position\n\t_fnStart( oSettings );\n\n\t/* Provide a pre-callback function which can be used to cancel the draw is false is returned */\n\tvar aPreDraw = _fnCallbackFire( oSettings, 'aoPreDrawCallback', 'preDraw', [oSettings] );\n\tif ( $.inArray( false, aPreDraw ) !== -1 )\n\t{\n\t\t_fnProcessingDisplay( oSettings, false );\n\t\treturn;\n\t}\n\n\tvar anRows = [];\n\tvar iRowCount = 0;\n\tvar asStripeClasses = oSettings.asStripeClasses;\n\tvar iStripes = asStripeClasses.length;\n\tvar oLang = oSettings.oLanguage;\n\tvar bServerSide = _fnDataSource( oSettings ) == 'ssp';\n\tvar aiDisplay = oSettings.aiDisplay;\n\tvar iDisplayStart = oSettings._iDisplayStart;\n\tvar iDisplayEnd = oSettings.fnDisplayEnd();\n\n\toSettings.bDrawing = true;\n\n\t/* Server-side processing draw intercept */\n\tif ( oSettings.bDeferLoading )\n\t{\n\t\toSettings.bDeferLoading = false;\n\t\toSettings.iDraw++;\n\t\t_fnProcessingDisplay( oSettings, false );\n\t}\n\telse if ( !bServerSide )\n\t{\n\t\toSettings.iDraw++;\n\t}\n\telse if ( !oSettings.bDestroying && !ajaxComplete)\n\t{\n\t\t_fnAjaxUpdate( oSettings );\n\t\treturn;\n\t}\n\n\tif ( aiDisplay.length !== 0 )\n\t{\n\t\tvar iStart = bServerSide ? 0 : iDisplayStart;\n\t\tvar iEnd = bServerSide ? oSettings.aoData.length : iDisplayEnd;\n\n\t\tfor ( var j=iStart ; j<iEnd ; j++ )\n\t\t{\n\t\t\tvar iDataIndex = aiDisplay[j];\n\t\t\tvar aoData = oSettings.aoData[ iDataIndex ];\n\t\t\tif ( aoData.nTr === null )\n\t\t\t{\n\t\t\t\t_fnCreateTr( oSettings, iDataIndex );\n\t\t\t}\n\n\t\t\tvar nRow = aoData.nTr;\n\n\t\t\t/* Remove the old striping classes and then add the new one */\n\t\t\tif ( iStripes !== 0 )\n\t\t\t{\n\t\t\t\tvar sStripe = asStripeClasses[ iRowCount % iStripes ];\n\t\t\t\tif ( aoData._sRowStripe != sStripe )\n\t\t\t\t{\n\t\t\t\t\t$(nRow).removeClass( aoData._sRowStripe ).addClass( sStripe );\n\t\t\t\t\taoData._sRowStripe = sStripe;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Row callback functions - might want to manipulate the row\n\t\t\t// iRowCount and j are not currently documented. Are they at all\n\t\t\t// useful?\n\t\t\t_fnCallbackFire( oSettings, 'aoRowCallback', null,\n\t\t\t\t[nRow, aoData._aData, iRowCount, j, iDataIndex] );\n\n\t\t\tanRows.push( nRow );\n\t\t\tiRowCount++;\n\t\t}\n\t}\n\telse\n\t{\n\t\t/* Table is empty - create a row with an empty message in it */\n\t\tvar sZero = oLang.sZeroRecords;\n\t\tif ( oSettings.iDraw == 1 &&  _fnDataSource( oSettings ) == 'ajax' )\n\t\t{\n\t\t\tsZero = oLang.sLoadingRecords;\n\t\t}\n\t\telse if ( oLang.sEmptyTable && oSettings.fnRecordsTotal() === 0 )\n\t\t{\n\t\t\tsZero = oLang.sEmptyTable;\n\t\t}\n\n\t\tanRows[ 0 ] = $( '<tr/>', { 'class': iStripes ? asStripeClasses[0] : '' } )\n\t\t\t.append( $('<td />', {\n\t\t\t\t'valign':  'top',\n\t\t\t\t'colSpan': _fnVisbleColumns( oSettings ),\n\t\t\t\t'class':   oSettings.oClasses.sRowEmpty\n\t\t\t} ).html( sZero ) )[0];\n\t}\n\n\t/* Header and footer callbacks */\n\t_fnCallbackFire( oSettings, 'aoHeaderCallback', 'header', [ $(oSettings.nTHead).children('tr')[0],\n\t\t_fnGetDataMaster( oSettings ), iDisplayStart, iDisplayEnd, aiDisplay ] );\n\n\t_fnCallbackFire( oSettings, 'aoFooterCallback', 'footer', [ $(oSettings.nTFoot).children('tr')[0],\n\t\t_fnGetDataMaster( oSettings ), iDisplayStart, iDisplayEnd, aiDisplay ] );\n\n\tvar body = $(oSettings.nTBody);\n\n\tbody.children().detach();\n\tbody.append( $(anRows) );\n\n\t/* Call all required callback functions for the end of a draw */\n\t_fnCallbackFire( oSettings, 'aoDrawCallback', 'draw', [oSettings] );\n\n\t/* Draw is complete, sorting and filtering must be as well */\n\toSettings.bSorted = false;\n\toSettings.bFiltered = false;\n\toSettings.bDrawing = false;\n}\n\n\n/**\n * Redraw the table - taking account of the various features which are enabled\n *  @param {object} oSettings dataTables settings object\n *  @param {boolean} [holdPosition] Keep the current paging position. By default\n *    the paging is reset to the first page\n *  @memberof DataTable#oApi\n */\nfunction _fnReDraw( settings, holdPosition )\n{\n\tvar\n\t\tfeatures = settings.oFeatures,\n\t\tsort     = features.bSort,\n\t\tfilter   = features.bFilter;\n\n\tif ( sort ) {\n\t\t_fnSort( settings );\n\t}\n\n\tif ( filter ) {\n\t\t_fnFilterComplete( settings, settings.oPreviousSearch );\n\t}\n\telse {\n\t\t// No filtering, so we want to just use the display master\n\t\tsettings.aiDisplay = settings.aiDisplayMaster.slice();\n\t}\n\n\tif ( holdPosition !== true ) {\n\t\tsettings._iDisplayStart = 0;\n\t}\n\n\t// Let any modules know about the draw hold position state (used by\n\t// scrolling internally)\n\tsettings._drawHold = holdPosition;\n\n\t_fnDraw( settings );\n\n\tsettings._drawHold = false;\n}\n\n\n/**\n * Add the options to the page HTML for the table\n *  @param {object} oSettings dataTables settings object\n *  @memberof DataTable#oApi\n */\nfunction _fnAddOptionsHtml ( oSettings )\n{\n\tvar classes = oSettings.oClasses;\n\tvar table = $(oSettings.nTable);\n\tvar holding = $('<div/>').insertBefore( table ); // Holding element for speed\n\tvar features = oSettings.oFeatures;\n\n\t// All DataTables are wrapped in a div\n\tvar insert = $('<div/>', {\n\t\tid:      oSettings.sTableId+'_wrapper',\n\t\t'class': classes.sWrapper + (oSettings.nTFoot ? '' : ' '+classes.sNoFooter)\n\t} );\n\n\toSettings.nHolding = holding[0];\n\toSettings.nTableWrapper = insert[0];\n\toSettings.nTableReinsertBefore = oSettings.nTable.nextSibling;\n\n\t/* Loop over the user set positioning and place the elements as needed */\n\tvar aDom = oSettings.sDom.split('');\n\tvar featureNode, cOption, nNewNode, cNext, sAttr, j;\n\tfor ( var i=0 ; i<aDom.length ; i++ )\n\t{\n\t\tfeatureNode = null;\n\t\tcOption = aDom[i];\n\n\t\tif ( cOption == '<' )\n\t\t{\n\t\t\t/* New container div */\n\t\t\tnNewNode = $('<div/>')[0];\n\n\t\t\t/* Check to see if we should append an id and/or a class name to the container */\n\t\t\tcNext = aDom[i+1];\n\t\t\tif ( cNext == \"'\" || cNext == '\"' )\n\t\t\t{\n\t\t\t\tsAttr = \"\";\n\t\t\t\tj = 2;\n\t\t\t\twhile ( aDom[i+j] != cNext )\n\t\t\t\t{\n\t\t\t\t\tsAttr += aDom[i+j];\n\t\t\t\t\tj++;\n\t\t\t\t}\n\n\t\t\t\t/* Replace jQuery UI constants @todo depreciated */\n\t\t\t\tif ( sAttr == \"H\" )\n\t\t\t\t{\n\t\t\t\t\tsAttr = classes.sJUIHeader;\n\t\t\t\t}\n\t\t\t\telse if ( sAttr == \"F\" )\n\t\t\t\t{\n\t\t\t\t\tsAttr = classes.sJUIFooter;\n\t\t\t\t}\n\n\t\t\t\t/* The attribute can be in the format of \"#id.class\", \"#id\" or \"class\" This logic\n\t\t\t\t * breaks the string into parts and applies them as needed\n\t\t\t\t */\n\t\t\t\tif ( sAttr.indexOf('.') != -1 )\n\t\t\t\t{\n\t\t\t\t\tvar aSplit = sAttr.split('.');\n\t\t\t\t\tnNewNode.id = aSplit[0].substr(1, aSplit[0].length-1);\n\t\t\t\t\tnNewNode.className = aSplit[1];\n\t\t\t\t}\n\t\t\t\telse if ( sAttr.charAt(0) == \"#\" )\n\t\t\t\t{\n\t\t\t\t\tnNewNode.id = sAttr.substr(1, sAttr.length-1);\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\tnNewNode.className = sAttr;\n\t\t\t\t}\n\n\t\t\t\ti += j; /* Move along the position array */\n\t\t\t}\n\n\t\t\tinsert.append( nNewNode );\n\t\t\tinsert = $(nNewNode);\n\t\t}\n\t\telse if ( cOption == '>' )\n\t\t{\n\t\t\t/* End container div */\n\t\t\tinsert = insert.parent();\n\t\t}\n\t\t// @todo Move options into their own plugins?\n\t\telse if ( cOption == 'l' && features.bPaginate && features.bLengthChange )\n\t\t{\n\t\t\t/* Length */\n\t\t\tfeatureNode = _fnFeatureHtmlLength( oSettings );\n\t\t}\n\t\telse if ( cOption == 'f' && features.bFilter )\n\t\t{\n\t\t\t/* Filter */\n\t\t\tfeatureNode = _fnFeatureHtmlFilter( oSettings );\n\t\t}\n\t\telse if ( cOption == 'r' && features.bProcessing )\n\t\t{\n\t\t\t/* pRocessing */\n\t\t\tfeatureNode = _fnFeatureHtmlProcessing( oSettings );\n\t\t}\n\t\telse if ( cOption == 't' )\n\t\t{\n\t\t\t/* Table */\n\t\t\tfeatureNode = _fnFeatureHtmlTable( oSettings );\n\t\t}\n\t\telse if ( cOption ==  'i' && features.bInfo )\n\t\t{\n\t\t\t/* Info */\n\t\t\tfeatureNode = _fnFeatureHtmlInfo( oSettings );\n\t\t}\n\t\telse if ( cOption == 'p' && features.bPaginate )\n\t\t{\n\t\t\t/* Pagination */\n\t\t\tfeatureNode = _fnFeatureHtmlPaginate( oSettings );\n\t\t}\n\t\telse if ( DataTable.ext.feature.length !== 0 )\n\t\t{\n\t\t\t/* Plug-in features */\n\t\t\tvar aoFeatures = DataTable.ext.feature;\n\t\t\tfor ( var k=0, kLen=aoFeatures.length ; k<kLen ; k++ )\n\t\t\t{\n\t\t\t\tif ( cOption == aoFeatures[k].cFeature )\n\t\t\t\t{\n\t\t\t\t\tfeatureNode = aoFeatures[k].fnInit( oSettings );\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t/* Add to the 2D features array */\n\t\tif ( featureNode )\n\t\t{\n\t\t\tvar aanFeatures = oSettings.aanFeatures;\n\n\t\t\tif ( ! aanFeatures[cOption] )\n\t\t\t{\n\t\t\t\taanFeatures[cOption] = [];\n\t\t\t}\n\n\t\t\taanFeatures[cOption].push( featureNode );\n\t\t\tinsert.append( featureNode );\n\t\t}\n\t}\n\n\t/* Built our DOM structure - replace the holding div with what we want */\n\tholding.replaceWith( insert );\n\toSettings.nHolding = null;\n}\n\n\n/**\n * Use the DOM source to create up an array of header cells. The idea here is to\n * create a layout grid (array) of rows x columns, which contains a reference\n * to the cell that that point in the grid (regardless of col/rowspan), such that\n * any column / row could be removed and the new grid constructed\n *  @param array {object} aLayout Array to store the calculated layout in\n *  @param {node} nThead The header/footer element for the table\n *  @memberof DataTable#oApi\n */\nfunction _fnDetectHeader ( aLayout, nThead )\n{\n\tvar nTrs = $(nThead).children('tr');\n\tvar nTr, nCell;\n\tvar i, k, l, iLen, jLen, iColShifted, iColumn, iColspan, iRowspan;\n\tvar bUnique;\n\tvar fnShiftCol = function ( a, i, j ) {\n\t\tvar k = a[i];\n                while ( k[j] ) {\n\t\t\tj++;\n\t\t}\n\t\treturn j;\n\t};\n\n\taLayout.splice( 0, aLayout.length );\n\n\t/* We know how many rows there are in the layout - so prep it */\n\tfor ( i=0, iLen=nTrs.length ; i<iLen ; i++ )\n\t{\n\t\taLayout.push( [] );\n\t}\n\n\t/* Calculate a layout array */\n\tfor ( i=0, iLen=nTrs.length ; i<iLen ; i++ )\n\t{\n\t\tnTr = nTrs[i];\n\t\tiColumn = 0;\n\n\t\t/* For every cell in the row... */\n\t\tnCell = nTr.firstChild;\n\t\twhile ( nCell ) {\n\t\t\tif ( nCell.nodeName.toUpperCase() == \"TD\" ||\n\t\t\t     nCell.nodeName.toUpperCase() == \"TH\" )\n\t\t\t{\n\t\t\t\t/* Get the col and rowspan attributes from the DOM and sanitise them */\n\t\t\t\tiColspan = nCell.getAttribute('colspan') * 1;\n\t\t\t\tiRowspan = nCell.getAttribute('rowspan') * 1;\n\t\t\t\tiColspan = (!iColspan || iColspan===0 || iColspan===1) ? 1 : iColspan;\n\t\t\t\tiRowspan = (!iRowspan || iRowspan===0 || iRowspan===1) ? 1 : iRowspan;\n\n\t\t\t\t/* There might be colspan cells already in this row, so shift our target\n\t\t\t\t * accordingly\n\t\t\t\t */\n\t\t\t\tiColShifted = fnShiftCol( aLayout, i, iColumn );\n\n\t\t\t\t/* Cache calculation for unique columns */\n\t\t\t\tbUnique = iColspan === 1 ? true : false;\n\n\t\t\t\t/* If there is col / rowspan, copy the information into the layout grid */\n\t\t\t\tfor ( l=0 ; l<iColspan ; l++ )\n\t\t\t\t{\n\t\t\t\t\tfor ( k=0 ; k<iRowspan ; k++ )\n\t\t\t\t\t{\n\t\t\t\t\t\taLayout[i+k][iColShifted+l] = {\n\t\t\t\t\t\t\t\"cell\": nCell,\n\t\t\t\t\t\t\t\"unique\": bUnique\n\t\t\t\t\t\t};\n\t\t\t\t\t\taLayout[i+k].nTr = nTr;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tnCell = nCell.nextSibling;\n\t\t}\n\t}\n}\n\n\n/**\n * Get an array of unique th elements, one for each column\n *  @param {object} oSettings dataTables settings object\n *  @param {node} nHeader automatically detect the layout from this node - optional\n *  @param {array} aLayout thead/tfoot layout from _fnDetectHeader - optional\n *  @returns array {node} aReturn list of unique th's\n *  @memberof DataTable#oApi\n */\nfunction _fnGetUniqueThs ( oSettings, nHeader, aLayout )\n{\n\tvar aReturn = [];\n\tif ( !aLayout )\n\t{\n\t\taLayout = oSettings.aoHeader;\n\t\tif ( nHeader )\n\t\t{\n\t\t\taLayout = [];\n\t\t\t_fnDetectHeader( aLayout, nHeader );\n\t\t}\n\t}\n\n\tfor ( var i=0, iLen=aLayout.length ; i<iLen ; i++ )\n\t{\n\t\tfor ( var j=0, jLen=aLayout[i].length ; j<jLen ; j++ )\n\t\t{\n\t\t\tif ( aLayout[i][j].unique &&\n\t\t\t\t (!aReturn[j] || !oSettings.bSortCellsTop) )\n\t\t\t{\n\t\t\t\taReturn[j] = aLayout[i][j].cell;\n\t\t\t}\n\t\t}\n\t}\n\n\treturn aReturn;\n}\n\n/**\n * Set the start position for draw\n *  @param {object} oSettings dataTables settings object\n */\nfunction _fnStart( oSettings )\n{\n\tvar bServerSide = _fnDataSource( oSettings ) == 'ssp';\n\tvar iInitDisplayStart = oSettings.iInitDisplayStart;\n\n\t// Check and see if we have an initial draw position from state saving\n\tif ( iInitDisplayStart !== undefined && iInitDisplayStart !== -1 )\n\t{\n\t\toSettings._iDisplayStart = bServerSide ?\n\t\t\tiInitDisplayStart :\n\t\t\tiInitDisplayStart >= oSettings.fnRecordsDisplay() ?\n\t\t\t\t0 :\n\t\t\t\tiInitDisplayStart;\n\n\t\toSettings.iInitDisplayStart = -1;\n\t}\n}\n\n/**\n * Create an Ajax call based on the table's settings, taking into account that\n * parameters can have multiple forms, and backwards compatibility.\n *\n * @param {object} oSettings dataTables settings object\n * @param {array} data Data to send to the server, required by\n *     DataTables - may be augmented by developer callbacks\n * @param {function} fn Callback function to run when data is obtained\n */\nfunction _fnBuildAjax( oSettings, data, fn )\n{\n\t// Compatibility with 1.9-, allow fnServerData and event to manipulate\n\t_fnCallbackFire( oSettings, 'aoServerParams', 'serverParams', [data] );\n\n\t// Convert to object based for 1.10+ if using the old array scheme which can\n\t// come from server-side processing or serverParams\n\tif ( data && Array.isArray(data) ) {\n\t\tvar tmp = {};\n\t\tvar rbracket = /(.*?)\\[\\]$/;\n\n\t\t$.each( data, function (key, val) {\n\t\t\tvar match = val.name.match(rbracket);\n\n\t\t\tif ( match ) {\n\t\t\t\t// Support for arrays\n\t\t\t\tvar name = match[0];\n\n\t\t\t\tif ( ! tmp[ name ] ) {\n\t\t\t\t\ttmp[ name ] = [];\n\t\t\t\t}\n\t\t\t\ttmp[ name ].push( val.value );\n\t\t\t}\n\t\t\telse {\n\t\t\t\ttmp[val.name] = val.value;\n\t\t\t}\n\t\t} );\n\t\tdata = tmp;\n\t}\n\n\tvar ajaxData;\n\tvar ajax = oSettings.ajax;\n\tvar instance = oSettings.oInstance;\n\tvar callback = function ( json ) {\n\t\tvar status = oSettings.jqXHR\n\t\t\t? oSettings.jqXHR.status\n\t\t\t: null;\n\n\t\tif ( json === null || (typeof status === 'number' && status == 204 ) ) {\n\t\t\tjson = {};\n\t\t\t_fnAjaxDataSrc( oSettings, json, [] );\n\t\t}\n\n\t\tvar error = json.error || json.sError;\n\t\tif ( error ) {\n\t\t\t_fnLog( oSettings, 0, error );\n\t\t}\n\n\t\toSettings.json = json;\n\n\t\t_fnCallbackFire( oSettings, null, 'xhr', [oSettings, json, oSettings.jqXHR] );\n\t\tfn( json );\n\t};\n\n\tif ( $.isPlainObject( ajax ) && ajax.data )\n\t{\n\t\tajaxData = ajax.data;\n\n\t\tvar newData = typeof ajaxData === 'function' ?\n\t\t\tajaxData( data, oSettings ) :  // fn can manipulate data or return\n\t\t\tajaxData;                      // an object object or array to merge\n\n\t\t// If the function returned something, use that alone\n\t\tdata = typeof ajaxData === 'function' && newData ?\n\t\t\tnewData :\n\t\t\t$.extend( true, data, newData );\n\n\t\t// Remove the data property as we've resolved it already and don't want\n\t\t// jQuery to do it again (it is restored at the end of the function)\n\t\tdelete ajax.data;\n\t}\n\n\tvar baseAjax = {\n\t\t\"data\": data,\n\t\t\"success\": callback,\n\t\t\"dataType\": \"json\",\n\t\t\"cache\": false,\n\t\t\"type\": oSettings.sServerMethod,\n\t\t\"error\": function (xhr, error, thrown) {\n\t\t\tvar ret = _fnCallbackFire( oSettings, null, 'xhr', [oSettings, null, oSettings.jqXHR] );\n\n\t\t\tif ( $.inArray( true, ret ) === -1 ) {\n\t\t\t\tif ( error == \"parsererror\" ) {\n\t\t\t\t\t_fnLog( oSettings, 0, 'Invalid JSON response', 1 );\n\t\t\t\t}\n\t\t\t\telse if ( xhr.readyState === 4 ) {\n\t\t\t\t\t_fnLog( oSettings, 0, 'Ajax error', 7 );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t_fnProcessingDisplay( oSettings, false );\n\t\t}\n\t};\n\n\t// Store the data submitted for the API\n\toSettings.oAjaxData = data;\n\n\t// Allow plug-ins and external processes to modify the data\n\t_fnCallbackFire( oSettings, null, 'preXhr', [oSettings, data] );\n\n\tif ( oSettings.fnServerData )\n\t{\n\t\t// DataTables 1.9- compatibility\n\t\toSettings.fnServerData.call( instance,\n\t\t\toSettings.sAjaxSource,\n\t\t\t$.map( data, function (val, key) { // Need to convert back to 1.9 trad format\n\t\t\t\treturn { name: key, value: val };\n\t\t\t} ),\n\t\t\tcallback,\n\t\t\toSettings\n\t\t);\n\t}\n\telse if ( oSettings.sAjaxSource || typeof ajax === 'string' )\n\t{\n\t\t// DataTables 1.9- compatibility\n\t\toSettings.jqXHR = $.ajax( $.extend( baseAjax, {\n\t\t\turl: ajax || oSettings.sAjaxSource\n\t\t} ) );\n\t}\n\telse if ( typeof ajax === 'function' )\n\t{\n\t\t// Is a function - let the caller define what needs to be done\n\t\toSettings.jqXHR = ajax.call( instance, data, callback, oSettings );\n\t}\n\telse\n\t{\n\t\t// Object to extend the base settings\n\t\toSettings.jqXHR = $.ajax( $.extend( baseAjax, ajax ) );\n\n\t\t// Restore for next time around\n\t\tajax.data = ajaxData;\n\t}\n}\n\n\n/**\n * Update the table using an Ajax call\n *  @param {object} settings dataTables settings object\n *  @returns {boolean} Block the table drawing or not\n *  @memberof DataTable#oApi\n */\nfunction _fnAjaxUpdate( settings )\n{\n\tsettings.iDraw++;\n\t_fnProcessingDisplay( settings, true );\n\n\t// Keep track of drawHold state to handle scrolling after the Ajax call\n\tvar drawHold = settings._drawHold;\n\n\t_fnBuildAjax(\n\t\tsettings,\n\t\t_fnAjaxParameters( settings ),\n\t\tfunction(json) {\n\t\t\tsettings._drawHold = drawHold;\n\t\t\t_fnAjaxUpdateDraw( settings, json );\n\t\t\tsettings._drawHold = false;\n\t\t}\n\t);\n}\n\n\n/**\n * Build up the parameters in an object needed for a server-side processing\n * request. Note that this is basically done twice, is different ways - a modern\n * method which is used by default in DataTables 1.10 which uses objects and\n * arrays, or the 1.9- method with is name / value pairs. 1.9 method is used if\n * the sAjaxSource option is used in the initialisation, or the legacyAjax\n * option is set.\n *  @param {object} oSettings dataTables settings object\n *  @returns {bool} block the table drawing or not\n *  @memberof DataTable#oApi\n */\nfunction _fnAjaxParameters( settings )\n{\n\tvar\n\t\tcolumns = settings.aoColumns,\n\t\tcolumnCount = columns.length,\n\t\tfeatures = settings.oFeatures,\n\t\tpreSearch = settings.oPreviousSearch,\n\t\tpreColSearch = settings.aoPreSearchCols,\n\t\ti, data = [], dataProp, column, columnSearch,\n\t\tsort = _fnSortFlatten( settings ),\n\t\tdisplayStart = settings._iDisplayStart,\n\t\tdisplayLength = features.bPaginate !== false ?\n\t\t\tsettings._iDisplayLength :\n\t\t\t-1;\n\n\tvar param = function ( name, value ) {\n\t\tdata.push( { 'name': name, 'value': value } );\n\t};\n\n\t// DataTables 1.9- compatible method\n\tparam( 'sEcho',          settings.iDraw );\n\tparam( 'iColumns',       columnCount );\n\tparam( 'sColumns',       _pluck( columns, 'sName' ).join(',') );\n\tparam( 'iDisplayStart',  displayStart );\n\tparam( 'iDisplayLength', displayLength );\n\n\t// DataTables 1.10+ method\n\tvar d = {\n\t\tdraw:    settings.iDraw,\n\t\tcolumns: [],\n\t\torder:   [],\n\t\tstart:   displayStart,\n\t\tlength:  displayLength,\n\t\tsearch:  {\n\t\t\tvalue: preSearch.sSearch,\n\t\t\tregex: preSearch.bRegex\n\t\t}\n\t};\n\n\tfor ( i=0 ; i<columnCount ; i++ ) {\n\t\tcolumn = columns[i];\n\t\tcolumnSearch = preColSearch[i];\n\t\tdataProp = typeof column.mData==\"function\" ? 'function' : column.mData ;\n\n\t\td.columns.push( {\n\t\t\tdata:       dataProp,\n\t\t\tname:       column.sName,\n\t\t\tsearchable: column.bSearchable,\n\t\t\torderable:  column.bSortable,\n\t\t\tsearch:     {\n\t\t\t\tvalue: columnSearch.sSearch,\n\t\t\t\tregex: columnSearch.bRegex\n\t\t\t}\n\t\t} );\n\n\t\tparam( \"mDataProp_\"+i, dataProp );\n\n\t\tif ( features.bFilter ) {\n\t\t\tparam( 'sSearch_'+i,     columnSearch.sSearch );\n\t\t\tparam( 'bRegex_'+i,      columnSearch.bRegex );\n\t\t\tparam( 'bSearchable_'+i, column.bSearchable );\n\t\t}\n\n\t\tif ( features.bSort ) {\n\t\t\tparam( 'bSortable_'+i, column.bSortable );\n\t\t}\n\t}\n\n\tif ( features.bFilter ) {\n\t\tparam( 'sSearch', preSearch.sSearch );\n\t\tparam( 'bRegex', preSearch.bRegex );\n\t}\n\n\tif ( features.bSort ) {\n\t\t$.each( sort, function ( i, val ) {\n\t\t\td.order.push( { column: val.col, dir: val.dir } );\n\n\t\t\tparam( 'iSortCol_'+i, val.col );\n\t\t\tparam( 'sSortDir_'+i, val.dir );\n\t\t} );\n\n\t\tparam( 'iSortingCols', sort.length );\n\t}\n\n\t// If the legacy.ajax parameter is null, then we automatically decide which\n\t// form to use, based on sAjaxSource\n\tvar legacy = DataTable.ext.legacy.ajax;\n\tif ( legacy === null ) {\n\t\treturn settings.sAjaxSource ? data : d;\n\t}\n\n\t// Otherwise, if legacy has been specified then we use that to decide on the\n\t// form\n\treturn legacy ? data : d;\n}\n\n\n/**\n * Data the data from the server (nuking the old) and redraw the table\n *  @param {object} oSettings dataTables settings object\n *  @param {object} json json data return from the server.\n *  @param {string} json.sEcho Tracking flag for DataTables to match requests\n *  @param {int} json.iTotalRecords Number of records in the data set, not accounting for filtering\n *  @param {int} json.iTotalDisplayRecords Number of records in the data set, accounting for filtering\n *  @param {array} json.aaData The data to display on this page\n *  @param {string} [json.sColumns] Column ordering (sName, comma separated)\n *  @memberof DataTable#oApi\n */\nfunction _fnAjaxUpdateDraw ( settings, json )\n{\n\t// v1.10 uses camelCase variables, while 1.9 uses Hungarian notation.\n\t// Support both\n\tvar compat = function ( old, modern ) {\n\t\treturn json[old] !== undefined ? json[old] : json[modern];\n\t};\n\n\tvar data = _fnAjaxDataSrc( settings, json );\n\tvar draw            = compat( 'sEcho',                'draw' );\n\tvar recordsTotal    = compat( 'iTotalRecords',        'recordsTotal' );\n\tvar recordsFiltered = compat( 'iTotalDisplayRecords', 'recordsFiltered' );\n\n\tif ( draw !== undefined ) {\n\t\t// Protect against out of sequence returns\n\t\tif ( draw*1 < settings.iDraw ) {\n\t\t\treturn;\n\t\t}\n\t\tsettings.iDraw = draw * 1;\n\t}\n\n\t// No data in returned object, so rather than an array, we show an empty table\n\tif ( ! data ) {\n\t\tdata = [];\n\t}\n\n\t_fnClearTable( settings );\n\tsettings._iRecordsTotal   = parseInt(recordsTotal, 10);\n\tsettings._iRecordsDisplay = parseInt(recordsFiltered, 10);\n\n\tfor ( var i=0, ien=data.length ; i<ien ; i++ ) {\n\t\t_fnAddData( settings, data[i] );\n\t}\n\tsettings.aiDisplay = settings.aiDisplayMaster.slice();\n\n\t_fnDraw( settings, true );\n\n\tif ( ! settings._bInitComplete ) {\n\t\t_fnInitComplete( settings, json );\n\t}\n\n\t_fnProcessingDisplay( settings, false );\n}\n\n\n/**\n * Get the data from the JSON data source to use for drawing a table. Using\n * `_fnGetObjectDataFn` allows the data to be sourced from a property of the\n * source object, or from a processing function.\n *  @param {object} oSettings dataTables settings object\n *  @param  {object} json Data source object / array from the server\n *  @return {array} Array of data to use\n */\n function _fnAjaxDataSrc ( oSettings, json, write )\n {\n\tvar dataSrc = $.isPlainObject( oSettings.ajax ) && oSettings.ajax.dataSrc !== undefined ?\n\t\toSettings.ajax.dataSrc :\n\t\toSettings.sAjaxDataProp; // Compatibility with 1.9-.\n\n\tif ( ! write ) {\n\t\tif ( dataSrc === 'data' ) {\n\t\t\t// If the default, then we still want to support the old style, and safely ignore\n\t\t\t// it if possible\n\t\t\treturn json.aaData || json[dataSrc];\n\t\t}\n\n\t\treturn dataSrc !== \"\" ?\n\t\t\t_fnGetObjectDataFn( dataSrc )( json ) :\n\t\t\tjson;\n\t}\n\n\t// set\n\t_fnSetObjectDataFn( dataSrc )( json, write );\n}\n\n/**\n * Generate the node required for filtering text\n *  @returns {node} Filter control element\n *  @param {object} oSettings dataTables settings object\n *  @memberof DataTable#oApi\n */\nfunction _fnFeatureHtmlFilter ( settings )\n{\n\tvar classes = settings.oClasses;\n\tvar tableId = settings.sTableId;\n\tvar language = settings.oLanguage;\n\tvar previousSearch = settings.oPreviousSearch;\n\tvar features = settings.aanFeatures;\n\tvar input = '<input type=\"search\" class=\"'+classes.sFilterInput+'\"/>';\n\n\tvar str = language.sSearch;\n\tstr = str.match(/_INPUT_/) ?\n\t\tstr.replace('_INPUT_', input) :\n\t\tstr+input;\n\n\tvar filter = $('<div/>', {\n\t\t\t'id': ! features.f ? tableId+'_filter' : null,\n\t\t\t'class': classes.sFilter\n\t\t} )\n\t\t.append( $('<label/>' ).append( str ) );\n\n\tvar searchFn = function(event) {\n\t\t/* Update all other filter input elements for the new display */\n\t\tvar n = features.f;\n\t\tvar val = !this.value ? \"\" : this.value; // mental IE8 fix :-(\n\t\tif(previousSearch['return'] && event.key !== \"Enter\") {\n\t\t\treturn;\n\t\t}\n\t\t/* Now do the filter */\n\t\tif ( val != previousSearch.sSearch ) {\n\t\t\t_fnFilterComplete( settings, {\n\t\t\t\t\"sSearch\": val,\n\t\t\t\t\"bRegex\": previousSearch.bRegex,\n\t\t\t\t\"bSmart\": previousSearch.bSmart ,\n\t\t\t\t\"bCaseInsensitive\": previousSearch.bCaseInsensitive,\n\t\t\t\t\"return\": previousSearch['return']\n\t\t\t} );\n\n\t\t\t// Need to redraw, without resorting\n\t\t\tsettings._iDisplayStart = 0;\n\t\t\t_fnDraw( settings );\n\t\t}\n\t};\n\n\tvar searchDelay = settings.searchDelay !== null ?\n\t\tsettings.searchDelay :\n\t\t_fnDataSource( settings ) === 'ssp' ?\n\t\t\t400 :\n\t\t\t0;\n\n\tvar jqFilter = $('input', filter)\n\t\t.val( previousSearch.sSearch )\n\t\t.attr( 'placeholder', language.sSearchPlaceholder )\n\t\t.on(\n\t\t\t'keyup.DT search.DT input.DT paste.DT cut.DT',\n\t\t\tsearchDelay ?\n\t\t\t\t_fnThrottle( searchFn, searchDelay ) :\n\t\t\t\tsearchFn\n\t\t)\n\t\t.on( 'mouseup.DT', function(e) {\n\t\t\t// Edge fix! Edge 17 does not trigger anything other than mouse events when clicking\n\t\t\t// on the clear icon (Edge bug 17584515). This is safe in other browsers as `searchFn`\n\t\t\t// checks the value to see if it has changed. In other browsers it won't have.\n\t\t\tsetTimeout( function () {\n\t\t\t\tsearchFn.call(jqFilter[0], e);\n\t\t\t}, 10);\n\t\t} )\n\t\t.on( 'keypress.DT', function(e) {\n\t\t\t/* Prevent form submission */\n\t\t\tif ( e.keyCode == 13 ) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t} )\n\t\t.attr('aria-controls', tableId);\n\n\t// Update the input elements whenever the table is filtered\n\t$(settings.nTable).on( 'search.dt.DT', function ( ev, s ) {\n\t\tif ( settings === s ) {\n\t\t\t// IE9 throws an 'unknown error' if document.activeElement is used\n\t\t\t// inside an iframe or frame...\n\t\t\ttry {\n\t\t\t\tif ( jqFilter[0] !== document.activeElement ) {\n\t\t\t\t\tjqFilter.val( previousSearch.sSearch );\n\t\t\t\t}\n\t\t\t}\n\t\t\tcatch ( e ) {}\n\t\t}\n\t} );\n\n\treturn filter[0];\n}\n\n\n/**\n * Filter the table using both the global filter and column based filtering\n *  @param {object} oSettings dataTables settings object\n *  @param {object} oSearch search information\n *  @param {int} [iForce] force a research of the master array (1) or not (undefined or 0)\n *  @memberof DataTable#oApi\n */\nfunction _fnFilterComplete ( oSettings, oInput, iForce )\n{\n\tvar oPrevSearch = oSettings.oPreviousSearch;\n\tvar aoPrevSearch = oSettings.aoPreSearchCols;\n\tvar fnSaveFilter = function ( oFilter ) {\n\t\t/* Save the filtering values */\n\t\toPrevSearch.sSearch = oFilter.sSearch;\n\t\toPrevSearch.bRegex = oFilter.bRegex;\n\t\toPrevSearch.bSmart = oFilter.bSmart;\n\t\toPrevSearch.bCaseInsensitive = oFilter.bCaseInsensitive;\n\t\toPrevSearch['return'] = oFilter['return'];\n\t};\n\tvar fnRegex = function ( o ) {\n\t\t// Backwards compatibility with the bEscapeRegex option\n\t\treturn o.bEscapeRegex !== undefined ? !o.bEscapeRegex : o.bRegex;\n\t};\n\n\t// Resolve any column types that are unknown due to addition or invalidation\n\t// @todo As per sort - can this be moved into an event handler?\n\t_fnColumnTypes( oSettings );\n\n\t/* In server-side processing all filtering is done by the server, so no point hanging around here */\n\tif ( _fnDataSource( oSettings ) != 'ssp' )\n\t{\n\t\t/* Global filter */\n\t\t_fnFilter( oSettings, oInput.sSearch, iForce, fnRegex(oInput), oInput.bSmart, oInput.bCaseInsensitive );\n\t\tfnSaveFilter( oInput );\n\n\t\t/* Now do the individual column filter */\n\t\tfor ( var i=0 ; i<aoPrevSearch.length ; i++ )\n\t\t{\n\t\t\t_fnFilterColumn( oSettings, aoPrevSearch[i].sSearch, i, fnRegex(aoPrevSearch[i]),\n\t\t\t\taoPrevSearch[i].bSmart, aoPrevSearch[i].bCaseInsensitive );\n\t\t}\n\n\t\t/* Custom filtering */\n\t\t_fnFilterCustom( oSettings );\n\t}\n\telse\n\t{\n\t\tfnSaveFilter( oInput );\n\t}\n\n\t/* Tell the draw function we have been filtering */\n\toSettings.bFiltered = true;\n\t_fnCallbackFire( oSettings, null, 'search', [oSettings] );\n}\n\n\n/**\n * Apply custom filtering functions\n *  @param {object} oSettings dataTables settings object\n *  @memberof DataTable#oApi\n */\nfunction _fnFilterCustom( settings )\n{\n\tvar filters = DataTable.ext.search;\n\tvar displayRows = settings.aiDisplay;\n\tvar row, rowIdx;\n\n\tfor ( var i=0, ien=filters.length ; i<ien ; i++ ) {\n\t\tvar rows = [];\n\n\t\t// Loop over each row and see if it should be included\n\t\tfor ( var j=0, jen=displayRows.length ; j<jen ; j++ ) {\n\t\t\trowIdx = displayRows[ j ];\n\t\t\trow = settings.aoData[ rowIdx ];\n\n\t\t\tif ( filters[i]( settings, row._aFilterData, rowIdx, row._aData, j ) ) {\n\t\t\t\trows.push( rowIdx );\n\t\t\t}\n\t\t}\n\n\t\t// So the array reference doesn't break set the results into the\n\t\t// existing array\n\t\tdisplayRows.length = 0;\n\t\t$.merge( displayRows, rows );\n\t}\n}\n\n\n/**\n * Filter the table on a per-column basis\n *  @param {object} oSettings dataTables settings object\n *  @param {string} sInput string to filter on\n *  @param {int} iColumn column to filter\n *  @param {bool} bRegex treat search string as a regular expression or not\n *  @param {bool} bSmart use smart filtering or not\n *  @param {bool} bCaseInsensitive Do case insensitive matching or not\n *  @memberof DataTable#oApi\n */\nfunction _fnFilterColumn ( settings, searchStr, colIdx, regex, smart, caseInsensitive )\n{\n\tif ( searchStr === '' ) {\n\t\treturn;\n\t}\n\n\tvar data;\n\tvar out = [];\n\tvar display = settings.aiDisplay;\n\tvar rpSearch = _fnFilterCreateSearch( searchStr, regex, smart, caseInsensitive );\n\n\tfor ( var i=0 ; i<display.length ; i++ ) {\n\t\tdata = settings.aoData[ display[i] ]._aFilterData[ colIdx ];\n\n\t\tif ( rpSearch.test( data ) ) {\n\t\t\tout.push( display[i] );\n\t\t}\n\t}\n\n\tsettings.aiDisplay = out;\n}\n\n\n/**\n * Filter the data table based on user input and draw the table\n *  @param {object} settings dataTables settings object\n *  @param {string} input string to filter on\n *  @param {int} force optional - force a research of the master array (1) or not (undefined or 0)\n *  @param {bool} regex treat as a regular expression or not\n *  @param {bool} smart perform smart filtering or not\n *  @param {bool} caseInsensitive Do case insensitive matching or not\n *  @memberof DataTable#oApi\n */\nfunction _fnFilter( settings, input, force, regex, smart, caseInsensitive )\n{\n\tvar rpSearch = _fnFilterCreateSearch( input, regex, smart, caseInsensitive );\n\tvar prevSearch = settings.oPreviousSearch.sSearch;\n\tvar displayMaster = settings.aiDisplayMaster;\n\tvar display, invalidated, i;\n\tvar filtered = [];\n\n\t// Need to take account of custom filtering functions - always filter\n\tif ( DataTable.ext.search.length !== 0 ) {\n\t\tforce = true;\n\t}\n\n\t// Check if any of the rows were invalidated\n\tinvalidated = _fnFilterData( settings );\n\n\t// If the input is blank - we just want the full data set\n\tif ( input.length <= 0 ) {\n\t\tsettings.aiDisplay = displayMaster.slice();\n\t}\n\telse {\n\t\t// New search - start from the master array\n\t\tif ( invalidated ||\n\t\t\t force ||\n\t\t\t regex ||\n\t\t\t prevSearch.length > input.length ||\n\t\t\t input.indexOf(prevSearch) !== 0 ||\n\t\t\t settings.bSorted // On resort, the display master needs to be\n\t\t\t                  // re-filtered since indexes will have changed\n\t\t) {\n\t\t\tsettings.aiDisplay = displayMaster.slice();\n\t\t}\n\n\t\t// Search the display array\n\t\tdisplay = settings.aiDisplay;\n\n\t\tfor ( i=0 ; i<display.length ; i++ ) {\n\t\t\tif ( rpSearch.test( settings.aoData[ display[i] ]._sFilterRow ) ) {\n\t\t\t\tfiltered.push( display[i] );\n\t\t\t}\n\t\t}\n\n\t\tsettings.aiDisplay = filtered;\n\t}\n}\n\n\n/**\n * Build a regular expression object suitable for searching a table\n *  @param {string} sSearch string to search for\n *  @param {bool} bRegex treat as a regular expression or not\n *  @param {bool} bSmart perform smart filtering or not\n *  @param {bool} bCaseInsensitive Do case insensitive matching or not\n *  @returns {RegExp} constructed object\n *  @memberof DataTable#oApi\n */\nfunction _fnFilterCreateSearch( search, regex, smart, caseInsensitive )\n{\n\tsearch = regex ?\n\t\tsearch :\n\t\t_fnEscapeRegex( search );\n\t\n\tif ( smart ) {\n\t\t/* For smart filtering we want to allow the search to work regardless of\n\t\t * word order. We also want double quoted text to be preserved, so word\n\t\t * order is important - a la google. So this is what we want to\n\t\t * generate:\n\t\t * \n\t\t * ^(?=.*?\\bone\\b)(?=.*?\\btwo three\\b)(?=.*?\\bfour\\b).*$\n\t\t */\n\t\tvar a = $.map( search.match( /[\"\\u201C][^\"\\u201D]+[\"\\u201D]|[^ ]+/g ) || [''], function ( word ) {\n\t\t\tif ( word.charAt(0) === '\"' ) {\n\t\t\t\tvar m = word.match( /^\"(.*)\"$/ );\n\t\t\t\tword = m ? m[1] : word;\n\t\t\t}\n\t\t\telse if ( word.charAt(0) === '\\u201C' ) {\n\t\t\t\tvar m = word.match( /^\\u201C(.*)\\u201D$/ );\n\t\t\t\tword = m ? m[1] : word;\n\t\t\t}\n\n\t\t\treturn word.replace('\"', '');\n\t\t} );\n\n\t\tsearch = '^(?=.*?'+a.join( ')(?=.*?' )+').*$';\n\t}\n\n\treturn new RegExp( search, caseInsensitive ? 'i' : '' );\n}\n\n\n/**\n * Escape a string such that it can be used in a regular expression\n *  @param {string} sVal string to escape\n *  @returns {string} escaped string\n *  @memberof DataTable#oApi\n */\nvar _fnEscapeRegex = DataTable.util.escapeRegex;\n\nvar __filter_div = $('<div>')[0];\nvar __filter_div_textContent = __filter_div.textContent !== undefined;\n\n// Update the filtering data for each row if needed (by invalidation or first run)\nfunction _fnFilterData ( settings )\n{\n\tvar columns = settings.aoColumns;\n\tvar column;\n\tvar i, j, ien, jen, filterData, cellData, row;\n\tvar wasInvalidated = false;\n\n\tfor ( i=0, ien=settings.aoData.length ; i<ien ; i++ ) {\n\t\trow = settings.aoData[i];\n\n\t\tif ( ! row._aFilterData ) {\n\t\t\tfilterData = [];\n\n\t\t\tfor ( j=0, jen=columns.length ; j<jen ; j++ ) {\n\t\t\t\tcolumn = columns[j];\n\n\t\t\t\tif ( column.bSearchable ) {\n\t\t\t\t\tcellData = _fnGetCellData( settings, i, j, 'filter' );\n\n\t\t\t\t\t// Search in DataTables 1.10 is string based. In 1.11 this\n\t\t\t\t\t// should be altered to also allow strict type checking.\n\t\t\t\t\tif ( cellData === null ) {\n\t\t\t\t\t\tcellData = '';\n\t\t\t\t\t}\n\n\t\t\t\t\tif ( typeof cellData !== 'string' && cellData.toString ) {\n\t\t\t\t\t\tcellData = cellData.toString();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tcellData = '';\n\t\t\t\t}\n\n\t\t\t\t// If it looks like there is an HTML entity in the string,\n\t\t\t\t// attempt to decode it so sorting works as expected. Note that\n\t\t\t\t// we could use a single line of jQuery to do this, but the DOM\n\t\t\t\t// method used here is much faster https://jsperf.com/html-decode\n\t\t\t\tif ( cellData.indexOf && cellData.indexOf('&') !== -1 ) {\n\t\t\t\t\t__filter_div.innerHTML = cellData;\n\t\t\t\t\tcellData = __filter_div_textContent ?\n\t\t\t\t\t\t__filter_div.textContent :\n\t\t\t\t\t\t__filter_div.innerText;\n\t\t\t\t}\n\n\t\t\t\tif ( cellData.replace ) {\n\t\t\t\t\tcellData = cellData.replace(/[\\r\\n\\u2028]/g, '');\n\t\t\t\t}\n\n\t\t\t\tfilterData.push( cellData );\n\t\t\t}\n\n\t\t\trow._aFilterData = filterData;\n\t\t\trow._sFilterRow = filterData.join('  ');\n\t\t\twasInvalidated = true;\n\t\t}\n\t}\n\n\treturn wasInvalidated;\n}\n\n\n/**\n * Convert from the internal Hungarian notation to camelCase for external\n * interaction\n *  @param {object} obj Object to convert\n *  @returns {object} Inverted object\n *  @memberof DataTable#oApi\n */\nfunction _fnSearchToCamel ( obj )\n{\n\treturn {\n\t\tsearch:          obj.sSearch,\n\t\tsmart:           obj.bSmart,\n\t\tregex:           obj.bRegex,\n\t\tcaseInsensitive: obj.bCaseInsensitive\n\t};\n}\n\n\n\n/**\n * Convert from camelCase notation to the internal Hungarian. We could use the\n * Hungarian convert function here, but this is cleaner\n *  @param {object} obj Object to convert\n *  @returns {object} Inverted object\n *  @memberof DataTable#oApi\n */\nfunction _fnSearchToHung ( obj )\n{\n\treturn {\n\t\tsSearch:          obj.search,\n\t\tbSmart:           obj.smart,\n\t\tbRegex:           obj.regex,\n\t\tbCaseInsensitive: obj.caseInsensitive\n\t};\n}\n\n/**\n * Generate the node required for the info display\n *  @param {object} oSettings dataTables settings object\n *  @returns {node} Information element\n *  @memberof DataTable#oApi\n */\nfunction _fnFeatureHtmlInfo ( settings )\n{\n\tvar\n\t\ttid = settings.sTableId,\n\t\tnodes = settings.aanFeatures.i,\n\t\tn = $('<div/>', {\n\t\t\t'class': settings.oClasses.sInfo,\n\t\t\t'id': ! nodes ? tid+'_info' : null\n\t\t} );\n\n\tif ( ! nodes ) {\n\t\t// Update display on each draw\n\t\tsettings.aoDrawCallback.push( {\n\t\t\t\"fn\": _fnUpdateInfo,\n\t\t\t\"sName\": \"information\"\n\t\t} );\n\n\t\tn\n\t\t\t.attr( 'role', 'status' )\n\t\t\t.attr( 'aria-live', 'polite' );\n\n\t\t// Table is described by our info div\n\t\t$(settings.nTable).attr( 'aria-describedby', tid+'_info' );\n\t}\n\n\treturn n[0];\n}\n\n\n/**\n * Update the information elements in the display\n *  @param {object} settings dataTables settings object\n *  @memberof DataTable#oApi\n */\nfunction _fnUpdateInfo ( settings )\n{\n\t/* Show information about the table */\n\tvar nodes = settings.aanFeatures.i;\n\tif ( nodes.length === 0 ) {\n\t\treturn;\n\t}\n\n\tvar\n\t\tlang  = settings.oLanguage,\n\t\tstart = settings._iDisplayStart+1,\n\t\tend   = settings.fnDisplayEnd(),\n\t\tmax   = settings.fnRecordsTotal(),\n\t\ttotal = settings.fnRecordsDisplay(),\n\t\tout   = total ?\n\t\t\tlang.sInfo :\n\t\t\tlang.sInfoEmpty;\n\n\tif ( total !== max ) {\n\t\t/* Record set after filtering */\n\t\tout += ' ' + lang.sInfoFiltered;\n\t}\n\n\t// Convert the macros\n\tout += lang.sInfoPostFix;\n\tout = _fnInfoMacros( settings, out );\n\n\tvar callback = lang.fnInfoCallback;\n\tif ( callback !== null ) {\n\t\tout = callback.call( settings.oInstance,\n\t\t\tsettings, start, end, max, total, out\n\t\t);\n\t}\n\n\t$(nodes).html( out );\n}\n\n\nfunction _fnInfoMacros ( settings, str )\n{\n\t// When infinite scrolling, we are always starting at 1. _iDisplayStart is used only\n\t// internally\n\tvar\n\t\tformatter  = settings.fnFormatNumber,\n\t\tstart      = settings._iDisplayStart+1,\n\t\tlen        = settings._iDisplayLength,\n\t\tvis        = settings.fnRecordsDisplay(),\n\t\tall        = len === -1;\n\n\treturn str.\n\t\treplace(/_START_/g, formatter.call( settings, start ) ).\n\t\treplace(/_END_/g,   formatter.call( settings, settings.fnDisplayEnd() ) ).\n\t\treplace(/_MAX_/g,   formatter.call( settings, settings.fnRecordsTotal() ) ).\n\t\treplace(/_TOTAL_/g, formatter.call( settings, vis ) ).\n\t\treplace(/_PAGE_/g,  formatter.call( settings, all ? 1 : Math.ceil( start / len ) ) ).\n\t\treplace(/_PAGES_/g, formatter.call( settings, all ? 1 : Math.ceil( vis / len ) ) );\n}\n\n\n\n/**\n * Draw the table for the first time, adding all required features\n *  @param {object} settings dataTables settings object\n *  @memberof DataTable#oApi\n */\nfunction _fnInitialise ( settings )\n{\n\tvar i, iLen, iAjaxStart=settings.iInitDisplayStart;\n\tvar columns = settings.aoColumns, column;\n\tvar features = settings.oFeatures;\n\tvar deferLoading = settings.bDeferLoading; // value modified by the draw\n\n\t/* Ensure that the table data is fully initialised */\n\tif ( ! settings.bInitialised ) {\n\t\tsetTimeout( function(){ _fnInitialise( settings ); }, 200 );\n\t\treturn;\n\t}\n\n\t/* Show the display HTML options */\n\t_fnAddOptionsHtml( settings );\n\n\t/* Build and draw the header / footer for the table */\n\t_fnBuildHead( settings );\n\t_fnDrawHead( settings, settings.aoHeader );\n\t_fnDrawHead( settings, settings.aoFooter );\n\n\t/* Okay to show that something is going on now */\n\t_fnProcessingDisplay( settings, true );\n\n\t/* Calculate sizes for columns */\n\tif ( features.bAutoWidth ) {\n\t\t_fnCalculateColumnWidths( settings );\n\t}\n\n\tfor ( i=0, iLen=columns.length ; i<iLen ; i++ ) {\n\t\tcolumn = columns[i];\n\n\t\tif ( column.sWidth ) {\n\t\t\tcolumn.nTh.style.width = _fnStringToCss( column.sWidth );\n\t\t}\n\t}\n\n\t_fnCallbackFire( settings, null, 'preInit', [settings] );\n\n\t// If there is default sorting required - let's do it. The sort function\n\t// will do the drawing for us. Otherwise we draw the table regardless of the\n\t// Ajax source - this allows the table to look initialised for Ajax sourcing\n\t// data (show 'loading' message possibly)\n\t_fnReDraw( settings );\n\n\t// Server-side processing init complete is done by _fnAjaxUpdateDraw\n\tvar dataSrc = _fnDataSource( settings );\n\tif ( dataSrc != 'ssp' || deferLoading ) {\n\t\t// if there is an ajax source load the data\n\t\tif ( dataSrc == 'ajax' ) {\n\t\t\t_fnBuildAjax( settings, [], function(json) {\n\t\t\t\tvar aData = _fnAjaxDataSrc( settings, json );\n\n\t\t\t\t// Got the data - add it to the table\n\t\t\t\tfor ( i=0 ; i<aData.length ; i++ ) {\n\t\t\t\t\t_fnAddData( settings, aData[i] );\n\t\t\t\t}\n\n\t\t\t\t// Reset the init display for cookie saving. We've already done\n\t\t\t\t// a filter, and therefore cleared it before. So we need to make\n\t\t\t\t// it appear 'fresh'\n\t\t\t\tsettings.iInitDisplayStart = iAjaxStart;\n\n\t\t\t\t_fnReDraw( settings );\n\n\t\t\t\t_fnProcessingDisplay( settings, false );\n\t\t\t\t_fnInitComplete( settings, json );\n\t\t\t}, settings );\n\t\t}\n\t\telse {\n\t\t\t_fnProcessingDisplay( settings, false );\n\t\t\t_fnInitComplete( settings );\n\t\t}\n\t}\n}\n\n\n/**\n * Draw the table for the first time, adding all required features\n *  @param {object} oSettings dataTables settings object\n *  @param {object} [json] JSON from the server that completed the table, if using Ajax source\n *    with client-side processing (optional)\n *  @memberof DataTable#oApi\n */\nfunction _fnInitComplete ( settings, json )\n{\n\tsettings._bInitComplete = true;\n\n\t// When data was added after the initialisation (data or Ajax) we need to\n\t// calculate the column sizing\n\tif ( json || settings.oInit.aaData ) {\n\t\t_fnAdjustColumnSizing( settings );\n\t}\n\n\t_fnCallbackFire( settings, null, 'plugin-init', [settings, json] );\n\t_fnCallbackFire( settings, 'aoInitComplete', 'init', [settings, json] );\n}\n\n\nfunction _fnLengthChange ( settings, val )\n{\n\tvar len = parseInt( val, 10 );\n\tsettings._iDisplayLength = len;\n\n\t_fnLengthOverflow( settings );\n\n\t// Fire length change event\n\t_fnCallbackFire( settings, null, 'length', [settings, len] );\n}\n\n\n/**\n * Generate the node required for user display length changing\n *  @param {object} settings dataTables settings object\n *  @returns {node} Display length feature node\n *  @memberof DataTable#oApi\n */\nfunction _fnFeatureHtmlLength ( settings )\n{\n\tvar\n\t\tclasses  = settings.oClasses,\n\t\ttableId  = settings.sTableId,\n\t\tmenu     = settings.aLengthMenu,\n\t\td2       = Array.isArray( menu[0] ),\n\t\tlengths  = d2 ? menu[0] : menu,\n\t\tlanguage = d2 ? menu[1] : menu;\n\n\tvar select = $('<select/>', {\n\t\t'name':          tableId+'_length',\n\t\t'aria-controls': tableId,\n\t\t'class':         classes.sLengthSelect\n\t} );\n\n\tfor ( var i=0, ien=lengths.length ; i<ien ; i++ ) {\n\t\tselect[0][ i ] = new Option(\n\t\t\ttypeof language[i] === 'number' ?\n\t\t\t\tsettings.fnFormatNumber( language[i] ) :\n\t\t\t\tlanguage[i],\n\t\t\tlengths[i]\n\t\t);\n\t}\n\n\tvar div = $('<div><label/></div>').addClass( classes.sLength );\n\tif ( ! settings.aanFeatures.l ) {\n\t\tdiv[0].id = tableId+'_length';\n\t}\n\n\tdiv.children().append(\n\t\tsettings.oLanguage.sLengthMenu.replace( '_MENU_', select[0].outerHTML )\n\t);\n\n\t// Can't use `select` variable as user might provide their own and the\n\t// reference is broken by the use of outerHTML\n\t$('select', div)\n\t\t.val( settings._iDisplayLength )\n\t\t.on( 'change.DT', function(e) {\n\t\t\t_fnLengthChange( settings, $(this).val() );\n\t\t\t_fnDraw( settings );\n\t\t} );\n\n\t// Update node value whenever anything changes the table's length\n\t$(settings.nTable).on( 'length.dt.DT', function (e, s, len) {\n\t\tif ( settings === s ) {\n\t\t\t$('select', div).val( len );\n\t\t}\n\t} );\n\n\treturn div[0];\n}\n\n\n\n/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n * Note that most of the paging logic is done in\n * DataTable.ext.pager\n */\n\n/**\n * Generate the node required for default pagination\n *  @param {object} oSettings dataTables settings object\n *  @returns {node} Pagination feature node\n *  @memberof DataTable#oApi\n */\nfunction _fnFeatureHtmlPaginate ( settings )\n{\n\tvar\n\t\ttype   = settings.sPaginationType,\n\t\tplugin = DataTable.ext.pager[ type ],\n\t\tmodern = typeof plugin === 'function',\n\t\tredraw = function( settings ) {\n\t\t\t_fnDraw( settings );\n\t\t},\n\t\tnode = $('<div/>').addClass( settings.oClasses.sPaging + type )[0],\n\t\tfeatures = settings.aanFeatures;\n\n\tif ( ! modern ) {\n\t\tplugin.fnInit( settings, node, redraw );\n\t}\n\n\t/* Add a draw callback for the pagination on first instance, to update the paging display */\n\tif ( ! features.p )\n\t{\n\t\tnode.id = settings.sTableId+'_paginate';\n\n\t\tsettings.aoDrawCallback.push( {\n\t\t\t\"fn\": function( settings ) {\n\t\t\t\tif ( modern ) {\n\t\t\t\t\tvar\n\t\t\t\t\t\tstart      = settings._iDisplayStart,\n\t\t\t\t\t\tlen        = settings._iDisplayLength,\n\t\t\t\t\t\tvisRecords = settings.fnRecordsDisplay(),\n\t\t\t\t\t\tall        = len === -1,\n\t\t\t\t\t\tpage = all ? 0 : Math.ceil( start / len ),\n\t\t\t\t\t\tpages = all ? 1 : Math.ceil( visRecords / len ),\n\t\t\t\t\t\tbuttons = plugin(page, pages),\n\t\t\t\t\t\ti, ien;\n\n\t\t\t\t\tfor ( i=0, ien=features.p.length ; i<ien ; i++ ) {\n\t\t\t\t\t\t_fnRenderer( settings, 'pageButton' )(\n\t\t\t\t\t\t\tsettings, features.p[i], i, buttons, page, pages\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tplugin.fnUpdate( settings, redraw );\n\t\t\t\t}\n\t\t\t},\n\t\t\t\"sName\": \"pagination\"\n\t\t} );\n\t}\n\n\treturn node;\n}\n\n\n/**\n * Alter the display settings to change the page\n *  @param {object} settings DataTables settings object\n *  @param {string|int} action Paging action to take: \"first\", \"previous\",\n *    \"next\" or \"last\" or page number to jump to (integer)\n *  @param [bool] redraw Automatically draw the update or not\n *  @returns {bool} true page has changed, false - no change\n *  @memberof DataTable#oApi\n */\nfunction _fnPageChange ( settings, action, redraw )\n{\n\tvar\n\t\tstart     = settings._iDisplayStart,\n\t\tlen       = settings._iDisplayLength,\n\t\trecords   = settings.fnRecordsDisplay();\n\n\tif ( records === 0 || len === -1 )\n\t{\n\t\tstart = 0;\n\t}\n\telse if ( typeof action === \"number\" )\n\t{\n\t\tstart = action * len;\n\n\t\tif ( start > records )\n\t\t{\n\t\t\tstart = 0;\n\t\t}\n\t}\n\telse if ( action == \"first\" )\n\t{\n\t\tstart = 0;\n\t}\n\telse if ( action == \"previous\" )\n\t{\n\t\tstart = len >= 0 ?\n\t\t\tstart - len :\n\t\t\t0;\n\n\t\tif ( start < 0 )\n\t\t{\n\t\t  start = 0;\n\t\t}\n\t}\n\telse if ( action == \"next\" )\n\t{\n\t\tif ( start + len < records )\n\t\t{\n\t\t\tstart += len;\n\t\t}\n\t}\n\telse if ( action == \"last\" )\n\t{\n\t\tstart = Math.floor( (records-1) / len) * len;\n\t}\n\telse\n\t{\n\t\t_fnLog( settings, 0, \"Unknown paging action: \"+action, 5 );\n\t}\n\n\tvar changed = settings._iDisplayStart !== start;\n\tsettings._iDisplayStart = start;\n\n\tif ( changed ) {\n\t\t_fnCallbackFire( settings, null, 'page', [settings] );\n\n\t\tif ( redraw ) {\n\t\t\t_fnDraw( settings );\n\t\t}\n\t}\n\telse {\n\t\t// No change event - paging was called, but no change\n\t\t_fnCallbackFire( settings, null, 'page-nc', [settings] );\n\t}\n\n\treturn changed;\n}\n\n\n\n/**\n * Generate the node required for the processing node\n *  @param {object} settings dataTables settings object\n *  @returns {node} Processing element\n *  @memberof DataTable#oApi\n */\nfunction _fnFeatureHtmlProcessing ( settings )\n{\n\treturn $('<div/>', {\n\t\t\t'id': ! settings.aanFeatures.r ? settings.sTableId+'_processing' : null,\n\t\t\t'class': settings.oClasses.sProcessing,\n\t\t\t'role': 'status'\n\t\t} )\n\t\t.html( settings.oLanguage.sProcessing )\n\t\t.append('<div><div></div><div></div><div></div><div></div></div>')\n\t\t.insertBefore( settings.nTable )[0];\n}\n\n\n/**\n * Display or hide the processing indicator\n *  @param {object} settings dataTables settings object\n *  @param {bool} show Show the processing indicator (true) or not (false)\n *  @memberof DataTable#oApi\n */\nfunction _fnProcessingDisplay ( settings, show )\n{\n\tif ( settings.oFeatures.bProcessing ) {\n\t\t$(settings.aanFeatures.r).css( 'display', show ? 'block' : 'none' );\n\t}\n\n\t_fnCallbackFire( settings, null, 'processing', [settings, show] );\n}\n\n/**\n * Add any control elements for the table - specifically scrolling\n *  @param {object} settings dataTables settings object\n *  @returns {node} Node to add to the DOM\n *  @memberof DataTable#oApi\n */\nfunction _fnFeatureHtmlTable ( settings )\n{\n\tvar table = $(settings.nTable);\n\n\t// Scrolling from here on in\n\tvar scroll = settings.oScroll;\n\n\tif ( scroll.sX === '' && scroll.sY === '' ) {\n\t\treturn settings.nTable;\n\t}\n\n\tvar scrollX = scroll.sX;\n\tvar scrollY = scroll.sY;\n\tvar classes = settings.oClasses;\n\tvar caption = table.children('caption');\n\tvar captionSide = caption.length ? caption[0]._captionSide : null;\n\tvar headerClone = $( table[0].cloneNode(false) );\n\tvar footerClone = $( table[0].cloneNode(false) );\n\tvar footer = table.children('tfoot');\n\tvar _div = '<div/>';\n\tvar size = function ( s ) {\n\t\treturn !s ? null : _fnStringToCss( s );\n\t};\n\n\tif ( ! footer.length ) {\n\t\tfooter = null;\n\t}\n\n\t/*\n\t * The HTML structure that we want to generate in this function is:\n\t *  div - scroller\n\t *    div - scroll head\n\t *      div - scroll head inner\n\t *        table - scroll head table\n\t *          thead - thead\n\t *    div - scroll body\n\t *      table - table (master table)\n\t *        thead - thead clone for sizing\n\t *        tbody - tbody\n\t *    div - scroll foot\n\t *      div - scroll foot inner\n\t *        table - scroll foot table\n\t *          tfoot - tfoot\n\t */\n\tvar scroller = $( _div, { 'class': classes.sScrollWrapper } )\n\t\t.append(\n\t\t\t$(_div, { 'class': classes.sScrollHead } )\n\t\t\t\t.css( {\n\t\t\t\t\toverflow: 'hidden',\n\t\t\t\t\tposition: 'relative',\n\t\t\t\t\tborder: 0,\n\t\t\t\t\twidth: scrollX ? size(scrollX) : '100%'\n\t\t\t\t} )\n\t\t\t\t.append(\n\t\t\t\t\t$(_div, { 'class': classes.sScrollHeadInner } )\n\t\t\t\t\t\t.css( {\n\t\t\t\t\t\t\t'box-sizing': 'content-box',\n\t\t\t\t\t\t\twidth: scroll.sXInner || '100%'\n\t\t\t\t\t\t} )\n\t\t\t\t\t\t.append(\n\t\t\t\t\t\t\theaderClone\n\t\t\t\t\t\t\t\t.removeAttr('id')\n\t\t\t\t\t\t\t\t.css( 'margin-left', 0 )\n\t\t\t\t\t\t\t\t.append( captionSide === 'top' ? caption : null )\n\t\t\t\t\t\t\t\t.append(\n\t\t\t\t\t\t\t\t\ttable.children('thead')\n\t\t\t\t\t\t\t\t)\n\t\t\t\t\t\t)\n\t\t\t\t)\n\t\t)\n\t\t.append(\n\t\t\t$(_div, { 'class': classes.sScrollBody } )\n\t\t\t\t.css( {\n\t\t\t\t\tposition: 'relative',\n\t\t\t\t\toverflow: 'auto',\n\t\t\t\t\twidth: size( scrollX )\n\t\t\t\t} )\n\t\t\t\t.append( table )\n\t\t);\n\n\tif ( footer ) {\n\t\tscroller.append(\n\t\t\t$(_div, { 'class': classes.sScrollFoot } )\n\t\t\t\t.css( {\n\t\t\t\t\toverflow: 'hidden',\n\t\t\t\t\tborder: 0,\n\t\t\t\t\twidth: scrollX ? size(scrollX) : '100%'\n\t\t\t\t} )\n\t\t\t\t.append(\n\t\t\t\t\t$(_div, { 'class': classes.sScrollFootInner } )\n\t\t\t\t\t\t.append(\n\t\t\t\t\t\t\tfooterClone\n\t\t\t\t\t\t\t\t.removeAttr('id')\n\t\t\t\t\t\t\t\t.css( 'margin-left', 0 )\n\t\t\t\t\t\t\t\t.append( captionSide === 'bottom' ? caption : null )\n\t\t\t\t\t\t\t\t.append(\n\t\t\t\t\t\t\t\t\ttable.children('tfoot')\n\t\t\t\t\t\t\t\t)\n\t\t\t\t\t\t)\n\t\t\t\t)\n\t\t);\n\t}\n\n\tvar children = scroller.children();\n\tvar scrollHead = children[0];\n\tvar scrollBody = children[1];\n\tvar scrollFoot = footer ? children[2] : null;\n\n\t// When the body is scrolled, then we also want to scroll the headers\n\tif ( scrollX ) {\n\t\t$(scrollBody).on( 'scroll.DT', function (e) {\n\t\t\tvar scrollLeft = this.scrollLeft;\n\n\t\t\tscrollHead.scrollLeft = scrollLeft;\n\n\t\t\tif ( footer ) {\n\t\t\t\tscrollFoot.scrollLeft = scrollLeft;\n\t\t\t}\n\t\t} );\n\t}\n\n\t$(scrollBody).css('max-height', scrollY);\n\tif (! scroll.bCollapse) {\n\t\t$(scrollBody).css('height', scrollY);\n\t}\n\n\tsettings.nScrollHead = scrollHead;\n\tsettings.nScrollBody = scrollBody;\n\tsettings.nScrollFoot = scrollFoot;\n\n\t// On redraw - align columns\n\tsettings.aoDrawCallback.push( {\n\t\t\"fn\": _fnScrollDraw,\n\t\t\"sName\": \"scrolling\"\n\t} );\n\n\treturn scroller[0];\n}\n\n\n\n/**\n * Update the header, footer and body tables for resizing - i.e. column\n * alignment.\n *\n * Welcome to the most horrible function DataTables. The process that this\n * function follows is basically:\n *   1. Re-create the table inside the scrolling div\n *   2. Take live measurements from the DOM\n *   3. Apply the measurements to align the columns\n *   4. Clean up\n *\n *  @param {object} settings dataTables settings object\n *  @memberof DataTable#oApi\n */\nfunction _fnScrollDraw ( settings )\n{\n\t// Given that this is such a monster function, a lot of variables are use\n\t// to try and keep the minimised size as small as possible\n\tvar\n\t\tscroll         = settings.oScroll,\n\t\tscrollX        = scroll.sX,\n\t\tscrollXInner   = scroll.sXInner,\n\t\tscrollY        = scroll.sY,\n\t\tbarWidth       = scroll.iBarWidth,\n\t\tdivHeader      = $(settings.nScrollHead),\n\t\tdivHeaderStyle = divHeader[0].style,\n\t\tdivHeaderInner = divHeader.children('div'),\n\t\tdivHeaderInnerStyle = divHeaderInner[0].style,\n\t\tdivHeaderTable = divHeaderInner.children('table'),\n\t\tdivBodyEl      = settings.nScrollBody,\n\t\tdivBody        = $(divBodyEl),\n\t\tdivBodyStyle   = divBodyEl.style,\n\t\tdivFooter      = $(settings.nScrollFoot),\n\t\tdivFooterInner = divFooter.children('div'),\n\t\tdivFooterTable = divFooterInner.children('table'),\n\t\theader         = $(settings.nTHead),\n\t\ttable          = $(settings.nTable),\n\t\ttableEl        = table[0],\n\t\ttableStyle     = tableEl.style,\n\t\tfooter         = settings.nTFoot ? $(settings.nTFoot) : null,\n\t\tbrowser        = settings.oBrowser,\n\t\tie67           = browser.bScrollOversize,\n\t\tdtHeaderCells  = _pluck( settings.aoColumns, 'nTh' ),\n\t\theaderTrgEls, footerTrgEls,\n\t\theaderSrcEls, footerSrcEls,\n\t\theaderCopy, footerCopy,\n\t\theaderWidths=[], footerWidths=[],\n\t\theaderContent=[], footerContent=[],\n\t\tidx, correction, sanityWidth,\n\t\tzeroOut = function(nSizer) {\n\t\t\tvar style = nSizer.style;\n\t\t\tstyle.paddingTop = \"0\";\n\t\t\tstyle.paddingBottom = \"0\";\n\t\t\tstyle.borderTopWidth = \"0\";\n\t\t\tstyle.borderBottomWidth = \"0\";\n\t\t\tstyle.height = 0;\n\t\t};\n\n\t// If the scrollbar visibility has changed from the last draw, we need to\n\t// adjust the column sizes as the table width will have changed to account\n\t// for the scrollbar\n\tvar scrollBarVis = divBodyEl.scrollHeight > divBodyEl.clientHeight;\n\t\n\tif ( settings.scrollBarVis !== scrollBarVis && settings.scrollBarVis !== undefined ) {\n\t\tsettings.scrollBarVis = scrollBarVis;\n\t\t_fnAdjustColumnSizing( settings );\n\t\treturn; // adjust column sizing will call this function again\n\t}\n\telse {\n\t\tsettings.scrollBarVis = scrollBarVis;\n\t}\n\n\t/*\n\t * 1. Re-create the table inside the scrolling div\n\t */\n\n\t// Remove the old minimised thead and tfoot elements in the inner table\n\ttable.children('thead, tfoot').remove();\n\n\tif ( footer ) {\n\t\tfooterCopy = footer.clone().prependTo( table );\n\t\tfooterTrgEls = footer.find('tr'); // the original tfoot is in its own table and must be sized\n\t\tfooterSrcEls = footerCopy.find('tr');\n\t\tfooterCopy.find('[id]').removeAttr('id');\n\t}\n\n\t// Clone the current header and footer elements and then place it into the inner table\n\theaderCopy = header.clone().prependTo( table );\n\theaderTrgEls = header.find('tr'); // original header is in its own table\n\theaderSrcEls = headerCopy.find('tr');\n\theaderCopy.find('th, td').removeAttr('tabindex');\n\theaderCopy.find('[id]').removeAttr('id');\n\n\n\t/*\n\t * 2. Take live measurements from the DOM - do not alter the DOM itself!\n\t */\n\n\t// Remove old sizing and apply the calculated column widths\n\t// Get the unique column headers in the newly created (cloned) header. We want to apply the\n\t// calculated sizes to this header\n\tif ( ! scrollX )\n\t{\n\t\tdivBodyStyle.width = '100%';\n\t\tdivHeader[0].style.width = '100%';\n\t}\n\n\t$.each( _fnGetUniqueThs( settings, headerCopy ), function ( i, el ) {\n\t\tidx = _fnVisibleToColumnIndex( settings, i );\n\t\tel.style.width = settings.aoColumns[idx].sWidth;\n\t} );\n\n\tif ( footer ) {\n\t\t_fnApplyToChildren( function(n) {\n\t\t\tn.style.width = \"\";\n\t\t}, footerSrcEls );\n\t}\n\n\t// Size the table as a whole\n\tsanityWidth = table.outerWidth();\n\tif ( scrollX === \"\" ) {\n\t\t// No x scrolling\n\t\ttableStyle.width = \"100%\";\n\n\t\t// IE7 will make the width of the table when 100% include the scrollbar\n\t\t// - which is shouldn't. When there is a scrollbar we need to take this\n\t\t// into account.\n\t\tif ( ie67 && (table.find('tbody').height() > divBodyEl.offsetHeight ||\n\t\t\tdivBody.css('overflow-y') == \"scroll\")\n\t\t) {\n\t\t\ttableStyle.width = _fnStringToCss( table.outerWidth() - barWidth);\n\t\t}\n\n\t\t// Recalculate the sanity width\n\t\tsanityWidth = table.outerWidth();\n\t}\n\telse if ( scrollXInner !== \"\" ) {\n\t\t// legacy x scroll inner has been given - use it\n\t\ttableStyle.width = _fnStringToCss(scrollXInner);\n\n\t\t// Recalculate the sanity width\n\t\tsanityWidth = table.outerWidth();\n\t}\n\n\t// Hidden header should have zero height, so remove padding and borders. Then\n\t// set the width based on the real headers\n\n\t// Apply all styles in one pass\n\t_fnApplyToChildren( zeroOut, headerSrcEls );\n\n\t// Read all widths in next pass\n\t_fnApplyToChildren( function(nSizer) {\n\t\tvar style = window.getComputedStyle ?\n\t\t\twindow.getComputedStyle(nSizer).width :\n\t\t\t_fnStringToCss( $(nSizer).width() );\n\n\t\theaderContent.push( nSizer.innerHTML );\n\t\theaderWidths.push( style );\n\t}, headerSrcEls );\n\n\t// Apply all widths in final pass\n\t_fnApplyToChildren( function(nToSize, i) {\n\t\tnToSize.style.width = headerWidths[i];\n\t}, headerTrgEls );\n\n\t$(headerSrcEls).css('height', 0);\n\n\t/* Same again with the footer if we have one */\n\tif ( footer )\n\t{\n\t\t_fnApplyToChildren( zeroOut, footerSrcEls );\n\n\t\t_fnApplyToChildren( function(nSizer) {\n\t\t\tfooterContent.push( nSizer.innerHTML );\n\t\t\tfooterWidths.push( _fnStringToCss( $(nSizer).css('width') ) );\n\t\t}, footerSrcEls );\n\n\t\t_fnApplyToChildren( function(nToSize, i) {\n\t\t\tnToSize.style.width = footerWidths[i];\n\t\t}, footerTrgEls );\n\n\t\t$(footerSrcEls).height(0);\n\t}\n\n\n\t/*\n\t * 3. Apply the measurements\n\t */\n\n\t// \"Hide\" the header and footer that we used for the sizing. We need to keep\n\t// the content of the cell so that the width applied to the header and body\n\t// both match, but we want to hide it completely. We want to also fix their\n\t// width to what they currently are\n\t_fnApplyToChildren( function(nSizer, i) {\n\t\tnSizer.innerHTML = '<div class=\"dataTables_sizing\">'+headerContent[i]+'</div>';\n\t\tnSizer.childNodes[0].style.height = \"0\";\n\t\tnSizer.childNodes[0].style.overflow = \"hidden\";\n\t\tnSizer.style.width = headerWidths[i];\n\t}, headerSrcEls );\n\n\tif ( footer )\n\t{\n\t\t_fnApplyToChildren( function(nSizer, i) {\n\t\t\tnSizer.innerHTML = '<div class=\"dataTables_sizing\">'+footerContent[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 = footerWidths[i];\n\t\t}, footerSrcEls );\n\t}\n\n\t// Sanity check that the table is of a sensible width. If not then we are going to get\n\t// misalignment - try to prevent this by not allowing the table to shrink below its min width\n\tif ( Math.round(table.outerWidth()) < Math.round(sanityWidth) )\n\t{\n\t\t// The min width depends upon if we have a vertical scrollbar visible or not */\n\t\tcorrection = ((divBodyEl.scrollHeight > divBodyEl.offsetHeight ||\n\t\t\tdivBody.css('overflow-y') == \"scroll\")) ?\n\t\t\t\tsanityWidth+barWidth :\n\t\t\t\tsanityWidth;\n\n\t\t// IE6/7 are a law unto themselves...\n\t\tif ( ie67 && (divBodyEl.scrollHeight >\n\t\t\tdivBodyEl.offsetHeight || divBody.css('overflow-y') == \"scroll\")\n\t\t) {\n\t\t\ttableStyle.width = _fnStringToCss( correction-barWidth );\n\t\t}\n\n\t\t// And give the user a warning that we've stopped the table getting too small\n\t\tif ( scrollX === \"\" || scrollXInner !== \"\" ) {\n\t\t\t_fnLog( settings, 1, 'Possible column misalignment', 6 );\n\t\t}\n\t}\n\telse\n\t{\n\t\tcorrection = '100%';\n\t}\n\n\t// Apply to the container elements\n\tdivBodyStyle.width = _fnStringToCss( correction );\n\tdivHeaderStyle.width = _fnStringToCss( correction );\n\n\tif ( footer ) {\n\t\tsettings.nScrollFoot.style.width = _fnStringToCss( correction );\n\t}\n\n\n\t/*\n\t * 4. Clean up\n\t */\n\tif ( ! scrollY ) {\n\t\t/* IE7< puts a vertical scrollbar in place (when it shouldn't be) due to subtracting\n\t\t * the scrollbar height from the visible display, rather than adding it on. We need to\n\t\t * set the height in order to sort this. Don't want to do it in any other browsers.\n\t\t */\n\t\tif ( ie67 ) {\n\t\t\tdivBodyStyle.height = _fnStringToCss( tableEl.offsetHeight+barWidth );\n\t\t}\n\t}\n\n\t/* Finally set the width's of the header and footer tables */\n\tvar iOuterWidth = table.outerWidth();\n\tdivHeaderTable[0].style.width = _fnStringToCss( iOuterWidth );\n\tdivHeaderInnerStyle.width = _fnStringToCss( iOuterWidth );\n\n\t// Figure out if there are scrollbar present - if so then we need a the header and footer to\n\t// provide a bit more space to allow \"overflow\" scrolling (i.e. past the scrollbar)\n\tvar bScrolling = table.height() > divBodyEl.clientHeight || divBody.css('overflow-y') == \"scroll\";\n\tvar padding = 'padding' + (browser.bScrollbarLeft ? 'Left' : 'Right' );\n\tdivHeaderInnerStyle[ padding ] = bScrolling ? barWidth+\"px\" : \"0px\";\n\n\tif ( footer ) {\n\t\tdivFooterTable[0].style.width = _fnStringToCss( iOuterWidth );\n\t\tdivFooterInner[0].style.width = _fnStringToCss( iOuterWidth );\n\t\tdivFooterInner[0].style[padding] = bScrolling ? barWidth+\"px\" : \"0px\";\n\t}\n\n\t// Correct DOM ordering for colgroup - comes before the thead\n\ttable.children('colgroup').insertBefore( table.children('thead') );\n\n\t/* Adjust the position of the header in case we loose the y-scrollbar */\n\tdivBody.trigger('scroll');\n\n\t// If sorting or filtering has occurred, jump the scrolling back to the top\n\t// only if we aren't holding the position\n\tif ( (settings.bSorted || settings.bFiltered) && ! settings._drawHold ) {\n\t\tdivBodyEl.scrollTop = 0;\n\t}\n}\n\n\n\n/**\n * Apply a given function to the display child nodes of an element array (typically\n * TD children of TR rows\n *  @param {function} fn Method to apply to the objects\n *  @param array {nodes} an1 List of elements to look through for display children\n *  @param array {nodes} an2 Another list (identical structure to the first) - optional\n *  @memberof DataTable#oApi\n */\nfunction _fnApplyToChildren( fn, an1, an2 )\n{\n\tvar index=0, i=0, iLen=an1.length;\n\tvar nNode1, nNode2;\n\n\twhile ( i < iLen ) {\n\t\tnNode1 = an1[i].firstChild;\n\t\tnNode2 = an2 ? an2[i].firstChild : null;\n\n\t\twhile ( nNode1 ) {\n\t\t\tif ( nNode1.nodeType === 1 ) {\n\t\t\t\tif ( an2 ) {\n\t\t\t\t\tfn( nNode1, nNode2, index );\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tfn( nNode1, index );\n\t\t\t\t}\n\n\t\t\t\tindex++;\n\t\t\t}\n\n\t\t\tnNode1 = nNode1.nextSibling;\n\t\t\tnNode2 = an2 ? nNode2.nextSibling : null;\n\t\t}\n\n\t\ti++;\n\t}\n}\n\n\n\nvar __re_html_remove = /<.*?>/g;\n\n\n/**\n * Calculate the width of columns for the table\n *  @param {object} oSettings dataTables settings object\n *  @memberof DataTable#oApi\n */\nfunction _fnCalculateColumnWidths ( oSettings )\n{\n\tvar\n\t\ttable = oSettings.nTable,\n\t\tcolumns = oSettings.aoColumns,\n\t\tscroll = oSettings.oScroll,\n\t\tscrollY = scroll.sY,\n\t\tscrollX = scroll.sX,\n\t\tscrollXInner = scroll.sXInner,\n\t\tcolumnCount = columns.length,\n\t\tvisibleColumns = _fnGetColumns( oSettings, 'bVisible' ),\n\t\theaderCells = $('th', oSettings.nTHead),\n\t\ttableWidthAttr = table.getAttribute('width'), // from DOM element\n\t\ttableContainer = table.parentNode,\n\t\tuserInputs = false,\n\t\ti, column, columnIdx, width, outerWidth,\n\t\tbrowser = oSettings.oBrowser,\n\t\tie67 = browser.bScrollOversize;\n\n\tvar styleWidth = table.style.width;\n\tif ( styleWidth && styleWidth.indexOf('%') !== -1 ) {\n\t\ttableWidthAttr = styleWidth;\n\t}\n\n\t/* Convert any user input sizes into pixel sizes */\n\tvar sizes = _fnConvertToWidth(_pluck(columns, 'sWidthOrig'), tableContainer);\n\n\tfor ( i=0 ; i<visibleColumns.length ; i++ ) {\n\t\tcolumn = columns[ visibleColumns[i] ];\n\n\t\tif ( column.sWidth !== null ) {\n\t\t\tcolumn.sWidth = sizes[i];\n\n\t\t\tuserInputs = true;\n\t\t}\n\t}\n\n\t/* If the number of columns in the DOM equals the number that we have to\n\t * process in DataTables, then we can use the offsets that are created by\n\t * the web- browser. No custom sizes can be set in order for this to happen,\n\t * nor scrolling used\n\t */\n\tif ( ie67 || ! userInputs && ! scrollX && ! scrollY &&\n\t     columnCount == _fnVisbleColumns( oSettings ) &&\n\t     columnCount == headerCells.length\n\t) {\n\t\tfor ( i=0 ; i<columnCount ; i++ ) {\n\t\t\tvar colIdx = _fnVisibleToColumnIndex( oSettings, i );\n\n\t\t\tif ( colIdx !== null ) {\n\t\t\t\tcolumns[ colIdx ].sWidth = _fnStringToCss( headerCells.eq(i).width() );\n\t\t\t}\n\t\t}\n\t}\n\telse\n\t{\n\t\t// Otherwise construct a single row, worst case, table with the widest\n\t\t// node in the data, assign any user defined widths, then insert it into\n\t\t// the DOM and allow the browser to do all the hard work of calculating\n\t\t// table widths\n\t\tvar tmpTable = $(table).clone() // don't use cloneNode - IE8 will remove events on the main table\n\t\t\t.css( 'visibility', 'hidden' )\n\t\t\t.removeAttr( 'id' );\n\n\t\t// Clean up the table body\n\t\ttmpTable.find('tbody tr').remove();\n\t\tvar tr = $('<tr/>').appendTo( tmpTable.find('tbody') );\n\n\t\t// Clone the table header and footer - we can't use the header / footer\n\t\t// from the cloned table, since if scrolling is active, the table's\n\t\t// real header and footer are contained in different table tags\n\t\ttmpTable.find('thead, tfoot').remove();\n\t\ttmpTable\n\t\t\t.append( $(oSettings.nTHead).clone() )\n\t\t\t.append( $(oSettings.nTFoot).clone() );\n\n\t\t// Remove any assigned widths from the footer (from scrolling)\n\t\ttmpTable.find('tfoot th, tfoot td').css('width', '');\n\n\t\t// Apply custom sizing to the cloned header\n\t\theaderCells = _fnGetUniqueThs( oSettings, tmpTable.find('thead')[0] );\n\n\t\tfor ( i=0 ; i<visibleColumns.length ; i++ ) {\n\t\t\tcolumn = columns[ visibleColumns[i] ];\n\n\t\t\theaderCells[i].style.width = column.sWidthOrig !== null && column.sWidthOrig !== '' ?\n\t\t\t\t_fnStringToCss( column.sWidthOrig ) :\n\t\t\t\t'';\n\n\t\t\t// For scrollX we need to force the column width otherwise the\n\t\t\t// browser will collapse it. If this width is smaller than the\n\t\t\t// width the column requires, then it will have no effect\n\t\t\tif ( column.sWidthOrig && scrollX ) {\n\t\t\t\t$( headerCells[i] ).append( $('<div/>').css( {\n\t\t\t\t\twidth: column.sWidthOrig,\n\t\t\t\t\tmargin: 0,\n\t\t\t\t\tpadding: 0,\n\t\t\t\t\tborder: 0,\n\t\t\t\t\theight: 1\n\t\t\t\t} ) );\n\t\t\t}\n\t\t}\n\n\t\t// Find the widest cell for each column and put it into the table\n\t\tif ( oSettings.aoData.length ) {\n\t\t\tfor ( i=0 ; i<visibleColumns.length ; i++ ) {\n\t\t\t\tcolumnIdx = visibleColumns[i];\n\t\t\t\tcolumn = columns[ columnIdx ];\n\n\t\t\t\t$( _fnGetWidestNode( oSettings, columnIdx ) )\n\t\t\t\t\t.clone( false )\n\t\t\t\t\t.append( column.sContentPadding )\n\t\t\t\t\t.appendTo( tr );\n\t\t\t}\n\t\t}\n\n\t\t// Tidy the temporary table - remove name attributes so there aren't\n\t\t// duplicated in the dom (radio elements for example)\n\t\t$('[name]', tmpTable).removeAttr('name');\n\n\t\t// Table has been built, attach to the document so we can work with it.\n\t\t// A holding element is used, positioned at the top of the container\n\t\t// with minimal height, so it has no effect on if the container scrolls\n\t\t// or not. Otherwise it might trigger scrolling when it actually isn't\n\t\t// needed\n\t\tvar holder = $('<div/>').css( scrollX || scrollY ?\n\t\t\t\t{\n\t\t\t\t\tposition: 'absolute',\n\t\t\t\t\ttop: 0,\n\t\t\t\t\tleft: 0,\n\t\t\t\t\theight: 1,\n\t\t\t\t\tright: 0,\n\t\t\t\t\toverflow: 'hidden'\n\t\t\t\t} :\n\t\t\t\t{}\n\t\t\t)\n\t\t\t.append( tmpTable )\n\t\t\t.appendTo( tableContainer );\n\n\t\t// When scrolling (X or Y) we want to set the width of the table as \n\t\t// appropriate. However, when not scrolling leave the table width as it\n\t\t// is. This results in slightly different, but I think correct behaviour\n\t\tif ( scrollX && scrollXInner ) {\n\t\t\ttmpTable.width( scrollXInner );\n\t\t}\n\t\telse if ( scrollX ) {\n\t\t\ttmpTable.css( 'width', 'auto' );\n\t\t\ttmpTable.removeAttr('width');\n\n\t\t\t// If there is no width attribute or style, then allow the table to\n\t\t\t// collapse\n\t\t\tif ( tmpTable.width() < tableContainer.clientWidth && tableWidthAttr ) {\n\t\t\t\ttmpTable.width( tableContainer.clientWidth );\n\t\t\t}\n\t\t}\n\t\telse if ( scrollY ) {\n\t\t\ttmpTable.width( tableContainer.clientWidth );\n\t\t}\n\t\telse if ( tableWidthAttr ) {\n\t\t\ttmpTable.width( tableWidthAttr );\n\t\t}\n\n\t\t// Get the width of each column in the constructed table - we need to\n\t\t// know the inner width (so it can be assigned to the other table's\n\t\t// cells) and the outer width so we can calculate the full width of the\n\t\t// table. This is safe since DataTables requires a unique cell for each\n\t\t// column, but if ever a header can span multiple columns, this will\n\t\t// need to be modified.\n\t\tvar total = 0;\n\t\tfor ( i=0 ; i<visibleColumns.length ; i++ ) {\n\t\t\tvar cell = $(headerCells[i]);\n\t\t\tvar border = cell.outerWidth() - cell.width();\n\n\t\t\t// Use getBounding... where possible (not IE8-) because it can give\n\t\t\t// sub-pixel accuracy, which we then want to round up!\n\t\t\tvar bounding = browser.bBounding ?\n\t\t\t\tMath.ceil( headerCells[i].getBoundingClientRect().width ) :\n\t\t\t\tcell.outerWidth();\n\n\t\t\t// Total is tracked to remove any sub-pixel errors as the outerWidth\n\t\t\t// of the table might not equal the total given here (IE!).\n\t\t\ttotal += bounding;\n\n\t\t\t// Width for each column to use\n\t\t\tcolumns[ visibleColumns[i] ].sWidth = _fnStringToCss( bounding - border );\n\t\t}\n\n\t\ttable.style.width = _fnStringToCss( total );\n\n\t\t// Finished with the table - ditch it\n\t\tholder.remove();\n\t}\n\n\t// If there is a width attr, we want to attach an event listener which\n\t// allows the table sizing to automatically adjust when the window is\n\t// resized. Use the width attr rather than CSS, since we can't know if the\n\t// CSS is a relative value or absolute - DOM read is always px.\n\tif ( tableWidthAttr ) {\n\t\ttable.style.width = _fnStringToCss( tableWidthAttr );\n\t}\n\n\tif ( (tableWidthAttr || scrollX) && ! oSettings._reszEvt ) {\n\t\tvar bindResize = function () {\n\t\t\t$(window).on('resize.DT-'+oSettings.sInstance, _fnThrottle( function () {\n\t\t\t\t_fnAdjustColumnSizing( oSettings );\n\t\t\t} ) );\n\t\t};\n\n\t\t// IE6/7 will crash if we bind a resize event handler on page load.\n\t\t// To be removed in 1.11 which drops IE6/7 support\n\t\tif ( ie67 ) {\n\t\t\tsetTimeout( bindResize, 1000 );\n\t\t}\n\t\telse {\n\t\t\tbindResize();\n\t\t}\n\n\t\toSettings._reszEvt = true;\n\t}\n}\n\n\n/**\n * Throttle the calls to a function. Arguments and context are maintained for\n * the throttled function\n *  @param {function} fn Function to be called\n *  @param {int} [freq=200] call frequency in mS\n *  @returns {function} wrapped function\n *  @memberof DataTable#oApi\n */\nvar _fnThrottle = DataTable.util.throttle;\n\n\n/**\n * Convert a set of CSS units width to pixels (e.g. 2em)\n *  @param {string[]} widths widths to be converted\n *  @param {node} parent parent to get the with for (required for relative widths) - optional\n *  @returns {int[]} widths in pixels\n *  @memberof DataTable#oApi\n */\nfunction _fnConvertToWidth ( widths, parent )\n{\n\tvar els = [];\n\tvar results = [];\n\n\t// Add the elements in a single loop so we only need to reflow once\n\tfor (var i=0 ; i<widths.length ; i++) {\n\t\tif (widths[i]) {\n\t\t\tels.push(\n\t\t\t\t$('<div/>')\n\t\t\t\t\t.css( 'width', _fnStringToCss( widths[i] ) )\n\t\t\t\t\t.appendTo( parent || document.body )\n\t\t\t)\n\t\t}\n\t\telse {\n\t\t\tels.push(null);\n\t\t}\n\t}\n\n\t// Get the sizes (will reflow once)\n\tfor (var i=0 ; i<widths.length ; i++) {\n\t\tresults.push(els[i] ? els[i][0].offsetWidth : null);\n\t}\n\n\t// Tidy\n\t$(els).remove();\n\n\treturn results;\n}\n\n\n/**\n * Get the widest node\n *  @param {object} settings dataTables settings object\n *  @param {int} colIdx column of interest\n *  @returns {node} widest table node\n *  @memberof DataTable#oApi\n */\nfunction _fnGetWidestNode( settings, colIdx )\n{\n\tvar idx = _fnGetMaxLenString( settings, colIdx );\n\tif ( idx < 0 ) {\n\t\treturn null;\n\t}\n\n\tvar data = settings.aoData[ idx ];\n\treturn ! data.nTr ? // Might not have been created when deferred rendering\n\t\t$('<td/>').html( _fnGetCellData( settings, idx, colIdx, 'display' ) )[0] :\n\t\tdata.anCells[ colIdx ];\n}\n\n\n/**\n * Get the maximum strlen for each data column\n *  @param {object} settings dataTables settings object\n *  @param {int} colIdx column of interest\n *  @returns {string} max string length for each column\n *  @memberof DataTable#oApi\n */\nfunction _fnGetMaxLenString( settings, colIdx )\n{\n\tvar s, max=-1, maxIdx = -1;\n\n\tfor ( var i=0, ien=settings.aoData.length ; i<ien ; i++ ) {\n\t\ts = _fnGetCellData( settings, i, colIdx, 'display' )+'';\n\t\ts = s.replace( __re_html_remove, '' );\n\t\ts = s.replace( /&nbsp;/g, ' ' );\n\n\t\tif ( s.length > max ) {\n\t\t\tmax = s.length;\n\t\t\tmaxIdx = i;\n\t\t}\n\t}\n\n\treturn maxIdx;\n}\n\n\n/**\n * Append a CSS unit (only if required) to a string\n *  @param {string} value to css-ify\n *  @returns {string} value with css unit\n *  @memberof DataTable#oApi\n */\nfunction _fnStringToCss( s )\n{\n\tif ( s === null ) {\n\t\treturn '0px';\n\t}\n\n\tif ( typeof s == 'number' ) {\n\t\treturn s < 0 ?\n\t\t\t'0px' :\n\t\t\ts+'px';\n\t}\n\n\t// Check it has a unit character already\n\treturn s.match(/\\d$/) ?\n\t\ts+'px' :\n\t\ts;\n}\n\n\n\nfunction _fnSortFlatten ( settings )\n{\n\tvar\n\t\ti, iLen, k, kLen,\n\t\taSort = [],\n\t\taiOrig = [],\n\t\taoColumns = settings.aoColumns,\n\t\taDataSort, iCol, sType, srcCol,\n\t\tfixed = settings.aaSortingFixed,\n\t\tfixedObj = $.isPlainObject( fixed ),\n\t\tnestedSort = [],\n\t\tadd = function ( a ) {\n\t\t\tif ( a.length && ! Array.isArray( a[0] ) ) {\n\t\t\t\t// 1D array\n\t\t\t\tnestedSort.push( a );\n\t\t\t}\n\t\t\telse {\n\t\t\t\t// 2D array\n\t\t\t\t$.merge( nestedSort, a );\n\t\t\t}\n\t\t};\n\n\t// Build the sort array, with pre-fix and post-fix options if they have been\n\t// specified\n\tif ( Array.isArray( fixed ) ) {\n\t\tadd( fixed );\n\t}\n\n\tif ( fixedObj && fixed.pre ) {\n\t\tadd( fixed.pre );\n\t}\n\n\tadd( settings.aaSorting );\n\n\tif (fixedObj && fixed.post ) {\n\t\tadd( fixed.post );\n\t}\n\n\tfor ( i=0 ; i<nestedSort.length ; i++ )\n\t{\n\t\tsrcCol = nestedSort[i][0];\n\t\taDataSort = aoColumns[ srcCol ].aDataSort;\n\n\t\tfor ( k=0, kLen=aDataSort.length ; k<kLen ; k++ )\n\t\t{\n\t\t\tiCol = aDataSort[k];\n\t\t\tsType = aoColumns[ iCol ].sType || 'string';\n\n\t\t\tif ( nestedSort[i]._idx === undefined ) {\n\t\t\t\tnestedSort[i]._idx = $.inArray( nestedSort[i][1], aoColumns[iCol].asSorting );\n\t\t\t}\n\n\t\t\taSort.push( {\n\t\t\t\tsrc:       srcCol,\n\t\t\t\tcol:       iCol,\n\t\t\t\tdir:       nestedSort[i][1],\n\t\t\t\tindex:     nestedSort[i]._idx,\n\t\t\t\ttype:      sType,\n\t\t\t\tformatter: DataTable.ext.type.order[ sType+\"-pre\" ]\n\t\t\t} );\n\t\t}\n\t}\n\n\treturn aSort;\n}\n\n/**\n * Change the order of the table\n *  @param {object} oSettings dataTables settings object\n *  @memberof DataTable#oApi\n *  @todo This really needs split up!\n */\nfunction _fnSort ( oSettings )\n{\n\tvar\n\t\ti, ien, iLen, j, jLen, k, kLen,\n\t\tsDataType, nTh,\n\t\taiOrig = [],\n\t\toExtSort = DataTable.ext.type.order,\n\t\taoData = oSettings.aoData,\n\t\taoColumns = oSettings.aoColumns,\n\t\taDataSort, data, iCol, sType, oSort,\n\t\tformatters = 0,\n\t\tsortCol,\n\t\tdisplayMaster = oSettings.aiDisplayMaster,\n\t\taSort;\n\n\t// Resolve any column types that are unknown due to addition or invalidation\n\t// @todo Can this be moved into a 'data-ready' handler which is called when\n\t//   data is going to be used in the table?\n\t_fnColumnTypes( oSettings );\n\n\taSort = _fnSortFlatten( oSettings );\n\n\tfor ( i=0, ien=aSort.length ; i<ien ; i++ ) {\n\t\tsortCol = aSort[i];\n\n\t\t// Track if we can use the fast sort algorithm\n\t\tif ( sortCol.formatter ) {\n\t\t\tformatters++;\n\t\t}\n\n\t\t// Load the data needed for the sort, for each cell\n\t\t_fnSortData( oSettings, sortCol.col );\n\t}\n\n\t/* No sorting required if server-side or no sorting array */\n\tif ( _fnDataSource( oSettings ) != 'ssp' && aSort.length !== 0 )\n\t{\n\t\t// Create a value - key array of the current row positions such that we can use their\n\t\t// current position during the sort, if values match, in order to perform stable sorting\n\t\tfor ( i=0, iLen=displayMaster.length ; i<iLen ; i++ ) {\n\t\t\taiOrig[ displayMaster[i] ] = i;\n\t\t}\n\n\t\t/* Do the sort - here we want multi-column sorting based on a given data source (column)\n\t\t * and sorting function (from oSort) in a certain direction. It's reasonably complex to\n\t\t * follow on it's own, but this is what we want (example two column sorting):\n\t\t *  fnLocalSorting = function(a,b){\n\t\t *    var iTest;\n\t\t *    iTest = oSort['string-asc']('data11', 'data12');\n\t\t *      if (iTest !== 0)\n\t\t *        return iTest;\n\t\t *    iTest = oSort['numeric-desc']('data21', 'data22');\n\t\t *    if (iTest !== 0)\n\t\t *      return iTest;\n\t\t *    return oSort['numeric-asc']( aiOrig[a], aiOrig[b] );\n\t\t *  }\n\t\t * Basically we have a test for each sorting column, if the data in that column is equal,\n\t\t * test the next column. If all columns match, then we use a numeric sort on the row\n\t\t * positions in the original data array to provide a stable sort.\n\t\t *\n\t\t * Note - I know it seems excessive to have two sorting methods, but the first is around\n\t\t * 15% faster, so the second is only maintained for backwards compatibility with sorting\n\t\t * methods which do not have a pre-sort formatting function.\n\t\t */\n\t\tif ( formatters === aSort.length ) {\n\t\t\t// All sort types have formatting functions\n\t\t\tdisplayMaster.sort( function ( a, b ) {\n\t\t\t\tvar\n\t\t\t\t\tx, y, k, test, sort,\n\t\t\t\t\tlen=aSort.length,\n\t\t\t\t\tdataA = aoData[a]._aSortData,\n\t\t\t\t\tdataB = aoData[b]._aSortData;\n\n\t\t\t\tfor ( k=0 ; k<len ; k++ ) {\n\t\t\t\t\tsort = aSort[k];\n\n\t\t\t\t\tx = dataA[ sort.col ];\n\t\t\t\t\ty = dataB[ sort.col ];\n\n\t\t\t\t\ttest = x<y ? -1 : x>y ? 1 : 0;\n\t\t\t\t\tif ( test !== 0 ) {\n\t\t\t\t\t\treturn sort.dir === 'asc' ? test : -test;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tx = aiOrig[a];\n\t\t\t\ty = aiOrig[b];\n\t\t\t\treturn x<y ? -1 : x>y ? 1 : 0;\n\t\t\t} );\n\t\t}\n\t\telse {\n\t\t\t// Depreciated - remove in 1.11 (providing a plug-in option)\n\t\t\t// Not all sort types have formatting methods, so we have to call their sorting\n\t\t\t// methods.\n\t\t\tdisplayMaster.sort( function ( a, b ) {\n\t\t\t\tvar\n\t\t\t\t\tx, y, k, l, test, sort, fn,\n\t\t\t\t\tlen=aSort.length,\n\t\t\t\t\tdataA = aoData[a]._aSortData,\n\t\t\t\t\tdataB = aoData[b]._aSortData;\n\n\t\t\t\tfor ( k=0 ; k<len ; k++ ) {\n\t\t\t\t\tsort = aSort[k];\n\n\t\t\t\t\tx = dataA[ sort.col ];\n\t\t\t\t\ty = dataB[ sort.col ];\n\n\t\t\t\t\tfn = oExtSort[ sort.type+\"-\"+sort.dir ] || oExtSort[ \"string-\"+sort.dir ];\n\t\t\t\t\ttest = fn( x, y );\n\t\t\t\t\tif ( test !== 0 ) {\n\t\t\t\t\t\treturn test;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tx = aiOrig[a];\n\t\t\t\ty = aiOrig[b];\n\t\t\t\treturn x<y ? -1 : x>y ? 1 : 0;\n\t\t\t} );\n\t\t}\n\t}\n\n\t/* Tell the draw function that we have sorted the data */\n\toSettings.bSorted = true;\n}\n\n\nfunction _fnSortAria ( settings )\n{\n\tvar label;\n\tvar nextSort;\n\tvar columns = settings.aoColumns;\n\tvar aSort = _fnSortFlatten( settings );\n\tvar oAria = settings.oLanguage.oAria;\n\n\t// ARIA attributes - need to loop all columns, to update all (removing old\n\t// attributes as needed)\n\tfor ( var i=0, iLen=columns.length ; i<iLen ; i++ )\n\t{\n\t\tvar col = columns[i];\n\t\tvar asSorting = col.asSorting;\n\t\tvar sTitle = col.ariaTitle || col.sTitle.replace( /<.*?>/g, \"\" );\n\t\tvar th = col.nTh;\n\n\t\t// IE7 is throwing an error when setting these properties with jQuery's\n\t\t// attr() and removeAttr() methods...\n\t\tth.removeAttribute('aria-sort');\n\n\t\t/* In ARIA only the first sorting column can be marked as sorting - no multi-sort option */\n\t\tif ( col.bSortable ) {\n\t\t\tif ( aSort.length > 0 && aSort[0].col == i ) {\n\t\t\t\tth.setAttribute('aria-sort', aSort[0].dir==\"asc\" ? \"ascending\" : \"descending\" );\n\t\t\t\tnextSort = asSorting[ aSort[0].index+1 ] || asSorting[0];\n\t\t\t}\n\t\t\telse {\n\t\t\t\tnextSort = asSorting[0];\n\t\t\t}\n\n\t\t\tlabel = sTitle + ( nextSort === \"asc\" ?\n\t\t\t\toAria.sSortAscending :\n\t\t\t\toAria.sSortDescending\n\t\t\t);\n\t\t}\n\t\telse {\n\t\t\tlabel = sTitle;\n\t\t}\n\n\t\tth.setAttribute('aria-label', label);\n\t}\n}\n\n\n/**\n * Function to run on user sort request\n *  @param {object} settings dataTables settings object\n *  @param {node} attachTo node to attach the handler to\n *  @param {int} colIdx column sorting index\n *  @param {boolean} [append=false] Append the requested sort to the existing\n *    sort if true (i.e. multi-column sort)\n *  @param {function} [callback] callback function\n *  @memberof DataTable#oApi\n */\nfunction _fnSortListener ( settings, colIdx, append, callback )\n{\n\tvar col = settings.aoColumns[ colIdx ];\n\tvar sorting = settings.aaSorting;\n\tvar asSorting = col.asSorting;\n\tvar nextSortIdx;\n\tvar next = function ( a, overflow ) {\n\t\tvar idx = a._idx;\n\t\tif ( idx === undefined ) {\n\t\t\tidx = $.inArray( a[1], asSorting );\n\t\t}\n\n\t\treturn idx+1 < asSorting.length ?\n\t\t\tidx+1 :\n\t\t\toverflow ?\n\t\t\t\tnull :\n\t\t\t\t0;\n\t};\n\n\t// Convert to 2D array if needed\n\tif ( typeof sorting[0] === 'number' ) {\n\t\tsorting = settings.aaSorting = [ sorting ];\n\t}\n\n\t// If appending the sort then we are multi-column sorting\n\tif ( append && settings.oFeatures.bSortMulti ) {\n\t\t// Are we already doing some kind of sort on this column?\n\t\tvar sortIdx = $.inArray( colIdx, _pluck(sorting, '0') );\n\n\t\tif ( sortIdx !== -1 ) {\n\t\t\t// Yes, modify the sort\n\t\t\tnextSortIdx = next( sorting[sortIdx], true );\n\n\t\t\tif ( nextSortIdx === null && sorting.length === 1 ) {\n\t\t\t\tnextSortIdx = 0; // can't remove sorting completely\n\t\t\t}\n\n\t\t\tif ( nextSortIdx === null ) {\n\t\t\t\tsorting.splice( sortIdx, 1 );\n\t\t\t}\n\t\t\telse {\n\t\t\t\tsorting[sortIdx][1] = asSorting[ nextSortIdx ];\n\t\t\t\tsorting[sortIdx]._idx = nextSortIdx;\n\t\t\t}\n\t\t}\n\t\telse {\n\t\t\t// No sort on this column yet\n\t\t\tsorting.push( [ colIdx, asSorting[0], 0 ] );\n\t\t\tsorting[sorting.length-1]._idx = 0;\n\t\t}\n\t}\n\telse if ( sorting.length && sorting[0][0] == colIdx ) {\n\t\t// Single column - already sorting on this column, modify the sort\n\t\tnextSortIdx = next( sorting[0] );\n\n\t\tsorting.length = 1;\n\t\tsorting[0][1] = asSorting[ nextSortIdx ];\n\t\tsorting[0]._idx = nextSortIdx;\n\t}\n\telse {\n\t\t// Single column - sort only on this column\n\t\tsorting.length = 0;\n\t\tsorting.push( [ colIdx, asSorting[0] ] );\n\t\tsorting[0]._idx = 0;\n\t}\n\n\t// Run the sort by calling a full redraw\n\t_fnReDraw( settings );\n\n\t// callback used for async user interaction\n\tif ( typeof callback == 'function' ) {\n\t\tcallback( settings );\n\t}\n}\n\n\n/**\n * Attach a sort handler (click) to a node\n *  @param {object} settings dataTables settings object\n *  @param {node} attachTo node to attach the handler to\n *  @param {int} colIdx column sorting index\n *  @param {function} [callback] callback function\n *  @memberof DataTable#oApi\n */\nfunction _fnSortAttachListener ( settings, attachTo, colIdx, callback )\n{\n\tvar col = settings.aoColumns[ colIdx ];\n\n\t_fnBindAction( attachTo, {}, function (e) {\n\t\t/* If the column is not sortable - don't to anything */\n\t\tif ( col.bSortable === false ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// If processing is enabled use a timeout to allow the processing\n\t\t// display to be shown - otherwise to it synchronously\n\t\tif ( settings.oFeatures.bProcessing ) {\n\t\t\t_fnProcessingDisplay( settings, true );\n\n\t\t\tsetTimeout( function() {\n\t\t\t\t_fnSortListener( settings, colIdx, e.shiftKey, callback );\n\n\t\t\t\t// In server-side processing, the draw callback will remove the\n\t\t\t\t// processing display\n\t\t\t\tif ( _fnDataSource( settings ) !== 'ssp' ) {\n\t\t\t\t\t_fnProcessingDisplay( settings, false );\n\t\t\t\t}\n\t\t\t}, 0 );\n\t\t}\n\t\telse {\n\t\t\t_fnSortListener( settings, colIdx, e.shiftKey, callback );\n\t\t}\n\t} );\n}\n\n\n/**\n * Set the sorting classes on table's body, Note: it is safe to call this function\n * when bSort and bSortClasses are false\n *  @param {object} oSettings dataTables settings object\n *  @memberof DataTable#oApi\n */\nfunction _fnSortingClasses( settings )\n{\n\tvar oldSort = settings.aLastSort;\n\tvar sortClass = settings.oClasses.sSortColumn;\n\tvar sort = _fnSortFlatten( settings );\n\tvar features = settings.oFeatures;\n\tvar i, ien, colIdx;\n\n\tif ( features.bSort && features.bSortClasses ) {\n\t\t// Remove old sorting classes\n\t\tfor ( i=0, ien=oldSort.length ; i<ien ; i++ ) {\n\t\t\tcolIdx = oldSort[i].src;\n\n\t\t\t// Remove column sorting\n\t\t\t$( _pluck( settings.aoData, 'anCells', colIdx ) )\n\t\t\t\t.removeClass( sortClass + (i<2 ? i+1 : 3) );\n\t\t}\n\n\t\t// Add new column sorting\n\t\tfor ( i=0, ien=sort.length ; i<ien ; i++ ) {\n\t\t\tcolIdx = sort[i].src;\n\n\t\t\t$( _pluck( settings.aoData, 'anCells', colIdx ) )\n\t\t\t\t.addClass( sortClass + (i<2 ? i+1 : 3) );\n\t\t}\n\t}\n\n\tsettings.aLastSort = sort;\n}\n\n\n// Get the data to sort a column, be it from cache, fresh (populating the\n// cache), or from a sort formatter\nfunction _fnSortData( settings, idx )\n{\n\t// Custom sorting function - provided by the sort data type\n\tvar column = settings.aoColumns[ idx ];\n\tvar customSort = DataTable.ext.order[ column.sSortDataType ];\n\tvar customData;\n\n\tif ( customSort ) {\n\t\tcustomData = customSort.call( settings.oInstance, settings, idx,\n\t\t\t_fnColumnIndexToVisible( settings, idx )\n\t\t);\n\t}\n\n\t// Use / populate cache\n\tvar row, cellData;\n\tvar formatter = DataTable.ext.type.order[ column.sType+\"-pre\" ];\n\n\tfor ( var i=0, ien=settings.aoData.length ; i<ien ; i++ ) {\n\t\trow = settings.aoData[i];\n\n\t\tif ( ! row._aSortData ) {\n\t\t\trow._aSortData = [];\n\t\t}\n\n\t\tif ( ! row._aSortData[idx] || customSort ) {\n\t\t\tcellData = customSort ?\n\t\t\t\tcustomData[i] : // If there was a custom sort function, use data from there\n\t\t\t\t_fnGetCellData( settings, i, idx, 'sort' );\n\n\t\t\trow._aSortData[ idx ] = formatter ?\n\t\t\t\tformatter( cellData ) :\n\t\t\t\tcellData;\n\t\t}\n\t}\n}\n\n\n\n/**\n * Save the state of a table\n *  @param {object} oSettings dataTables settings object\n *  @memberof DataTable#oApi\n */\nfunction _fnSaveState ( settings )\n{\n\tif (settings._bLoadingState) {\n\t\treturn;\n\t}\n\n\t/* Store the interesting variables */\n\tvar state = {\n\t\ttime:    +new Date(),\n\t\tstart:   settings._iDisplayStart,\n\t\tlength:  settings._iDisplayLength,\n\t\torder:   $.extend( true, [], settings.aaSorting ),\n\t\tsearch:  _fnSearchToCamel( settings.oPreviousSearch ),\n\t\tcolumns: $.map( settings.aoColumns, function ( col, i ) {\n\t\t\treturn {\n\t\t\t\tvisible: col.bVisible,\n\t\t\t\tsearch: _fnSearchToCamel( settings.aoPreSearchCols[i] )\n\t\t\t};\n\t\t} )\n\t};\n\n\tsettings.oSavedState = state;\n\t_fnCallbackFire( settings, \"aoStateSaveParams\", 'stateSaveParams', [settings, state] );\n\t\n\tif ( settings.oFeatures.bStateSave && !settings.bDestroying )\n\t{\n\t\tsettings.fnStateSaveCallback.call( settings.oInstance, settings, state );\n\t}\t\n}\n\n\n/**\n * Attempt to load a saved table state\n *  @param {object} oSettings dataTables settings object\n *  @param {object} oInit DataTables init object so we can override settings\n *  @param {function} callback Callback to execute when the state has been loaded\n *  @memberof DataTable#oApi\n */\nfunction _fnLoadState ( settings, oInit, callback )\n{\n\tif ( ! settings.oFeatures.bStateSave ) {\n\t\tcallback();\n\t\treturn;\n\t}\n\n\tvar loaded = function(state) {\n\t\t_fnImplementState(settings, state, callback);\n\t}\n\n\tvar state = settings.fnStateLoadCallback.call( settings.oInstance, settings, loaded );\n\n\tif ( state !== undefined ) {\n\t\t_fnImplementState( settings, state, callback );\n\t}\n\t// otherwise, wait for the loaded callback to be executed\n\n\treturn true;\n}\n\nfunction _fnImplementState ( settings, s, callback) {\n\tvar i, ien;\n\tvar columns = settings.aoColumns;\n\tsettings._bLoadingState = true;\n\n\t// When StateRestore was introduced the state could now be implemented at any time\n\t// Not just initialisation. To do this an api instance is required in some places\n\tvar api = settings._bInitComplete ? new DataTable.Api(settings) : null;\n\n\tif ( ! s || ! s.time ) {\n\t\tsettings._bLoadingState = false;\n\t\tcallback();\n\t\treturn;\n\t}\n\n\t// Allow custom and plug-in manipulation functions to alter the saved data set and\n\t// cancelling of loading by returning false\n\tvar abStateLoad = _fnCallbackFire( settings, 'aoStateLoadParams', 'stateLoadParams', [settings, s] );\n\tif ( $.inArray( false, abStateLoad ) !== -1 ) {\n\t\tsettings._bLoadingState = false;\n\t\tcallback();\n\t\treturn;\n\t}\n\n\t// Reject old data\n\tvar duration = settings.iStateDuration;\n\tif ( duration > 0 && s.time < +new Date() - (duration*1000) ) {\n\t\tsettings._bLoadingState = false;\n\t\tcallback();\n\t\treturn;\n\t}\n\n\t// Number of columns have changed - all bets are off, no restore of settings\n\tif ( s.columns && columns.length !== s.columns.length ) {\n\t\tsettings._bLoadingState = false;\n\t\tcallback();\n\t\treturn;\n\t}\n\n\t// Store the saved state so it might be accessed at any time\n\tsettings.oLoadedState = $.extend( true, {}, s );\n\n\t// Page Length\n\tif ( s.length !== undefined ) {\n\t\t// If already initialised just set the value directly so that the select element is also updated\n\t\tif (api) {\n\t\t\tapi.page.len(s.length)\n\t\t}\n\t\telse {\n\t\t\tsettings._iDisplayLength   = s.length;\n\t\t}\n\t}\n\n\t// Restore key features - todo - for 1.11 this needs to be done by\n\t// subscribed events\n\tif ( s.start !== undefined ) {\n\t\tif(api === null) {\n\t\t\tsettings._iDisplayStart    = s.start;\n\t\t\tsettings.iInitDisplayStart = s.start;\n\t\t}\n\t\telse {\n\t\t\t_fnPageChange(settings, s.start/settings._iDisplayLength);\n\t\t}\n\t}\n\n\t// Order\n\tif ( s.order !== undefined ) {\n\t\tsettings.aaSorting = [];\n\t\t$.each( s.order, function ( i, col ) {\n\t\t\tsettings.aaSorting.push( col[0] >= columns.length ?\n\t\t\t\t[ 0, col[1] ] :\n\t\t\t\tcol\n\t\t\t);\n\t\t} );\n\t}\n\n\t// Search\n\tif ( s.search !== undefined ) {\n\t\t$.extend( settings.oPreviousSearch, _fnSearchToHung( s.search ) );\n\t}\n\n\t// Columns\n\tif ( s.columns ) {\n\t\tfor ( i=0, ien=s.columns.length ; i<ien ; i++ ) {\n\t\t\tvar col = s.columns[i];\n\n\t\t\t// Visibility\n\t\t\tif ( col.visible !== undefined ) {\n\t\t\t\t// If the api is defined, the table has been initialised so we need to use it rather than internal settings\n\t\t\t\tif (api) {\n\t\t\t\t\t// Don't redraw the columns on every iteration of this loop, we will do this at the end instead\n\t\t\t\t\tapi.column(i).visible(col.visible, false);\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tcolumns[i].bVisible = col.visible;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Search\n\t\t\tif ( col.search !== undefined ) {\n\t\t\t\t$.extend( settings.aoPreSearchCols[i], _fnSearchToHung( col.search ) );\n\t\t\t}\n\t\t}\n\t\t\n\t\t// If the api is defined then we need to adjust the columns once the visibility has been changed\n\t\tif (api) {\n\t\t\tapi.columns.adjust();\n\t\t}\n\t}\n\n\tsettings._bLoadingState = false;\n\t_fnCallbackFire( settings, 'aoStateLoaded', 'stateLoaded', [settings, s] );\n\tcallback();\n};\n\n\n/**\n * Return the settings object for a particular table\n *  @param {node} table table we are using as a dataTable\n *  @returns {object} Settings object - or null if not found\n *  @memberof DataTable#oApi\n */\nfunction _fnSettingsFromNode ( table )\n{\n\tvar settings = DataTable.settings;\n\tvar idx = $.inArray( table, _pluck( settings, 'nTable' ) );\n\n\treturn idx !== -1 ?\n\t\tsettings[ idx ] :\n\t\tnull;\n}\n\n\n/**\n * Log an error message\n *  @param {object} settings dataTables settings object\n *  @param {int} level log error messages, or display them to the user\n *  @param {string} msg error message\n *  @param {int} tn Technical note id to get more information about the error.\n *  @memberof DataTable#oApi\n */\nfunction _fnLog( settings, level, msg, tn )\n{\n\tmsg = 'DataTables warning: '+\n\t\t(settings ? 'table id='+settings.sTableId+' - ' : '')+msg;\n\n\tif ( tn ) {\n\t\tmsg += '. For more information about this error, please see '+\n\t\t'https://datatables.net/tn/'+tn;\n\t}\n\n\tif ( ! level  ) {\n\t\t// Backwards compatibility pre 1.10\n\t\tvar ext = DataTable.ext;\n\t\tvar type = ext.sErrMode || ext.errMode;\n\n\t\tif ( settings ) {\n\t\t\t_fnCallbackFire( settings, null, 'error', [ settings, tn, msg ] );\n\t\t}\n\n\t\tif ( type == 'alert' ) {\n\t\t\talert( msg );\n\t\t}\n\t\telse if ( type == 'throw' ) {\n\t\t\tthrow new Error(msg);\n\t\t}\n\t\telse if ( typeof type == 'function' ) {\n\t\t\ttype( settings, tn, msg );\n\t\t}\n\t}\n\telse if ( window.console && console.log ) {\n\t\tconsole.log( msg );\n\t}\n}\n\n\n/**\n * See if a property is defined on one object, if so assign it to the other object\n *  @param {object} ret target object\n *  @param {object} src source object\n *  @param {string} name property\n *  @param {string} [mappedName] name to map too - optional, name used if not given\n *  @memberof DataTable#oApi\n */\nfunction _fnMap( ret, src, name, mappedName )\n{\n\tif ( Array.isArray( name ) ) {\n\t\t$.each( name, function (i, val) {\n\t\t\tif ( Array.isArray( val ) ) {\n\t\t\t\t_fnMap( ret, src, val[0], val[1] );\n\t\t\t}\n\t\t\telse {\n\t\t\t\t_fnMap( ret, src, val );\n\t\t\t}\n\t\t} );\n\n\t\treturn;\n\t}\n\n\tif ( mappedName === undefined ) {\n\t\tmappedName = name;\n\t}\n\n\tif ( src[name] !== undefined ) {\n\t\tret[mappedName] = src[name];\n\t}\n}\n\n\n/**\n * Extend objects - very similar to jQuery.extend, but deep copy objects, and\n * shallow copy arrays. The reason we need to do this, is that we don't want to\n * deep copy array init values (such as aaSorting) since the dev wouldn't be\n * able to override them, but we do want to deep copy arrays.\n *  @param {object} out Object to extend\n *  @param {object} extender Object from which the properties will be applied to\n *      out\n *  @param {boolean} breakRefs If true, then arrays will be sliced to take an\n *      independent copy with the exception of the `data` or `aaData` parameters\n *      if they are present. This is so you can pass in a collection to\n *      DataTables and have that used as your data source without breaking the\n *      references\n *  @returns {object} out Reference, just for convenience - out === the return.\n *  @memberof DataTable#oApi\n *  @todo This doesn't take account of arrays inside the deep copied objects.\n */\nfunction _fnExtend( out, extender, breakRefs )\n{\n\tvar val;\n\n\tfor ( var prop in extender ) {\n\t\tif ( extender.hasOwnProperty(prop) ) {\n\t\t\tval = extender[prop];\n\n\t\t\tif ( $.isPlainObject( val ) ) {\n\t\t\t\tif ( ! $.isPlainObject( out[prop] ) ) {\n\t\t\t\t\tout[prop] = {};\n\t\t\t\t}\n\t\t\t\t$.extend( true, out[prop], val );\n\t\t\t}\n\t\t\telse if ( breakRefs && prop !== 'data' && prop !== 'aaData' && Array.isArray(val) ) {\n\t\t\t\tout[prop] = val.slice();\n\t\t\t}\n\t\t\telse {\n\t\t\t\tout[prop] = val;\n\t\t\t}\n\t\t}\n\t}\n\n\treturn out;\n}\n\n\n/**\n * Bind an event handers to allow a click or return key to activate the callback.\n * This is good for accessibility since a return on the keyboard will have the\n * same effect as a click, if the element has focus.\n *  @param {element} n Element to bind the action to\n *  @param {object} oData Data object to pass to the triggered function\n *  @param {function} fn Callback function for when the event is triggered\n *  @memberof DataTable#oApi\n */\nfunction _fnBindAction( n, oData, fn )\n{\n\t$(n)\n\t\t.on( 'click.DT', oData, function (e) {\n\t\t\t\t$(n).trigger('blur'); // Remove focus outline for mouse users\n\t\t\t\tfn(e);\n\t\t\t} )\n\t\t.on( 'keypress.DT', oData, function (e){\n\t\t\t\tif ( e.which === 13 ) {\n\t\t\t\t\te.preventDefault();\n\t\t\t\t\tfn(e);\n\t\t\t\t}\n\t\t\t} )\n\t\t.on( 'selectstart.DT', function () {\n\t\t\t\t/* Take the brutal approach to cancelling text selection */\n\t\t\t\treturn false;\n\t\t\t} );\n}\n\n\n/**\n * Register a callback function. Easily allows a callback function to be added to\n * an array store of callback functions that can then all be called together.\n *  @param {object} oSettings dataTables settings object\n *  @param {string} sStore Name of the array storage for the callbacks in oSettings\n *  @param {function} fn Function to be called back\n *  @param {string} sName Identifying name for the callback (i.e. a label)\n *  @memberof DataTable#oApi\n */\nfunction _fnCallbackReg( oSettings, sStore, fn, sName )\n{\n\tif ( fn )\n\t{\n\t\toSettings[sStore].push( {\n\t\t\t\"fn\": fn,\n\t\t\t\"sName\": sName\n\t\t} );\n\t}\n}\n\n\n/**\n * Fire callback functions and trigger events. Note that the loop over the\n * callback array store is done backwards! Further note that you do not want to\n * fire off triggers in time sensitive applications (for example cell creation)\n * as its slow.\n *  @param {object} settings dataTables settings object\n *  @param {string} callbackArr Name of the array storage for the callbacks in\n *      oSettings\n *  @param {string} eventName Name of the jQuery custom event to trigger. If\n *      null no trigger is fired\n *  @param {array} args Array of arguments to pass to the callback function /\n *      trigger\n *  @memberof DataTable#oApi\n */\nfunction _fnCallbackFire( settings, callbackArr, eventName, args )\n{\n\tvar ret = [];\n\n\tif ( callbackArr ) {\n\t\tret = $.map( settings[callbackArr].slice().reverse(), function (val, i) {\n\t\t\treturn val.fn.apply( settings.oInstance, args );\n\t\t} );\n\t}\n\n\tif ( eventName !== null ) {\n\t\tvar e = $.Event( eventName+'.dt' );\n\t\tvar table = $(settings.nTable);\n\n\t\ttable.trigger( e, args );\n\n\t\t// If not yet attached to the document, trigger the event\n\t\t// on the body directly to sort of simulate the bubble\n\t\tif (table.parents('body').length === 0) {\n\t\t\t$('body').trigger( e, args );\n\t\t}\n\n\t\tret.push( e.result );\n\t}\n\n\treturn ret;\n}\n\n\nfunction _fnLengthOverflow ( settings )\n{\n\tvar\n\t\tstart = settings._iDisplayStart,\n\t\tend = settings.fnDisplayEnd(),\n\t\tlen = settings._iDisplayLength;\n\n\t/* If we have space to show extra rows (backing up from the end point - then do so */\n\tif ( start >= end )\n\t{\n\t\tstart = end - len;\n\t}\n\n\t// Keep the start record on the current page\n\tstart -= (start % len);\n\n\tif ( len === -1 || start < 0 )\n\t{\n\t\tstart = 0;\n\t}\n\n\tsettings._iDisplayStart = start;\n}\n\n\nfunction _fnRenderer( settings, type )\n{\n\tvar renderer = settings.renderer;\n\tvar host = DataTable.ext.renderer[type];\n\n\tif ( $.isPlainObject( renderer ) && renderer[type] ) {\n\t\t// Specific renderer for this type. If available use it, otherwise use\n\t\t// the default.\n\t\treturn host[renderer[type]] || host._;\n\t}\n\telse if ( typeof renderer === 'string' ) {\n\t\t// Common renderer - if there is one available for this type use it,\n\t\t// otherwise use the default\n\t\treturn host[renderer] || host._;\n\t}\n\n\t// Use the default\n\treturn host._;\n}\n\n\n/**\n * Detect the data source being used for the table. Used to simplify the code\n * a little (ajax) and to make it compress a little smaller.\n *\n *  @param {object} settings dataTables settings object\n *  @returns {string} Data source\n *  @memberof DataTable#oApi\n */\nfunction _fnDataSource ( settings )\n{\n\tif ( settings.oFeatures.bServerSide ) {\n\t\treturn 'ssp';\n\t}\n\telse if ( settings.ajax || settings.sAjaxSource ) {\n\t\treturn 'ajax';\n\t}\n\treturn 'dom';\n}\n\n\n\n\n/**\n * Computed structure of the DataTables API, defined by the options passed to\n * `DataTable.Api.register()` when building the API.\n *\n * The structure is built in order to speed creation and extension of the Api\n * objects since the extensions are effectively pre-parsed.\n *\n * The array is an array of objects with the following structure, where this\n * base array represents the Api prototype base:\n *\n *     [\n *       {\n *         name:      'data'                -- string   - Property name\n *         val:       function () {},       -- function - Api method (or undefined if just an object\n *         methodExt: [ ... ],              -- array    - Array of Api object definitions to extend the method result\n *         propExt:   [ ... ]               -- array    - Array of Api object definitions to extend the property\n *       },\n *       {\n *         name:     'row'\n *         val:       {},\n *         methodExt: [ ... ],\n *         propExt:   [\n *           {\n *             name:      'data'\n *             val:       function () {},\n *             methodExt: [ ... ],\n *             propExt:   [ ... ]\n *           },\n *           ...\n *         ]\n *       }\n *     ]\n *\n * @type {Array}\n * @ignore\n */\nvar __apiStruct = [];\n\n\n/**\n * `Array.prototype` reference.\n *\n * @type object\n * @ignore\n */\nvar __arrayProto = Array.prototype;\n\n\n/**\n * Abstraction for `context` parameter of the `Api` constructor to allow it to\n * take several different forms for ease of use.\n *\n * Each of the input parameter types will be converted to a DataTables settings\n * object where possible.\n *\n * @param  {string|node|jQuery|object} mixed DataTable identifier. Can be one\n *   of:\n *\n *   * `string` - jQuery selector. Any DataTables' matching the given selector\n *     with be found and used.\n *   * `node` - `TABLE` node which has already been formed into a DataTable.\n *   * `jQuery` - A jQuery object of `TABLE` nodes.\n *   * `object` - DataTables settings object\n *   * `DataTables.Api` - API instance\n * @return {array|null} Matching DataTables settings objects. `null` or\n *   `undefined` is returned if no matching DataTable is found.\n * @ignore\n */\nvar _toSettings = function ( mixed )\n{\n\tvar idx, jq;\n\tvar settings = DataTable.settings;\n\tvar tables = $.map( settings, function (el, i) {\n\t\treturn el.nTable;\n\t} );\n\n\tif ( ! mixed ) {\n\t\treturn [];\n\t}\n\telse if ( mixed.nTable && mixed.oApi ) {\n\t\t// DataTables settings object\n\t\treturn [ mixed ];\n\t}\n\telse if ( mixed.nodeName && mixed.nodeName.toLowerCase() === 'table' ) {\n\t\t// Table node\n\t\tidx = $.inArray( mixed, tables );\n\t\treturn idx !== -1 ? [ settings[idx] ] : null;\n\t}\n\telse if ( mixed && typeof mixed.settings === 'function' ) {\n\t\treturn mixed.settings().toArray();\n\t}\n\telse if ( typeof mixed === 'string' ) {\n\t\t// jQuery selector\n\t\tjq = $(mixed);\n\t}\n\telse if ( mixed instanceof $ ) {\n\t\t// jQuery object (also DataTables instance)\n\t\tjq = mixed;\n\t}\n\n\tif ( jq ) {\n\t\treturn jq.map( function(i) {\n\t\t\tidx = $.inArray( this, tables );\n\t\t\treturn idx !== -1 ? settings[idx] : null;\n\t\t} ).toArray();\n\t}\n};\n\n\n/**\n * DataTables API class - used to control and interface with  one or more\n * DataTables enhanced tables.\n *\n * The API class is heavily based on jQuery, presenting a chainable interface\n * that you can use to interact with tables. Each instance of the API class has\n * a \"context\" - i.e. the tables that it will operate on. This could be a single\n * table, all tables on a page or a sub-set thereof.\n *\n * Additionally the API is designed to allow you to easily work with the data in\n * the tables, retrieving and manipulating it as required. This is done by\n * presenting the API class as an array like interface. The contents of the\n * array depend upon the actions requested by each method (for example\n * `rows().nodes()` will return an array of nodes, while `rows().data()` will\n * return an array of objects or arrays depending upon your table's\n * configuration). The API object has a number of array like methods (`push`,\n * `pop`, `reverse` etc) as well as additional helper methods (`each`, `pluck`,\n * `unique` etc) to assist your working with the data held in a table.\n *\n * Most methods (those which return an Api instance) are chainable, which means\n * the return from a method call also has all of the methods available that the\n * top level object had. For example, these two calls are equivalent:\n *\n *     // Not chained\n *     api.row.add( {...} );\n *     api.draw();\n *\n *     // Chained\n *     api.row.add( {...} ).draw();\n *\n * @class DataTable.Api\n * @param {array|object|string|jQuery} context DataTable identifier. This is\n *   used to define which DataTables enhanced tables this API will operate on.\n *   Can be one of:\n *\n *   * `string` - jQuery selector. Any DataTables' matching the given selector\n *     with be found and used.\n *   * `node` - `TABLE` node which has already been formed into a DataTable.\n *   * `jQuery` - A jQuery object of `TABLE` nodes.\n *   * `object` - DataTables settings object\n * @param {array} [data] Data to initialise the Api instance with.\n *\n * @example\n *   // Direct initialisation during DataTables construction\n *   var api = $('#example').DataTable();\n *\n * @example\n *   // Initialisation using a DataTables jQuery object\n *   var api = $('#example').dataTable().api();\n *\n * @example\n *   // Initialisation as a constructor\n *   var api = new $.fn.DataTable.Api( 'table.dataTable' );\n */\n_Api = function ( context, data )\n{\n\tif ( ! (this instanceof _Api) ) {\n\t\treturn new _Api( context, data );\n\t}\n\n\tvar settings = [];\n\tvar ctxSettings = function ( o ) {\n\t\tvar a = _toSettings( o );\n\t\tif ( a ) {\n\t\t\tsettings.push.apply( settings, a );\n\t\t}\n\t};\n\n\tif ( Array.isArray( context ) ) {\n\t\tfor ( var i=0, ien=context.length ; i<ien ; i++ ) {\n\t\t\tctxSettings( context[i] );\n\t\t}\n\t}\n\telse {\n\t\tctxSettings( context );\n\t}\n\n\t// Remove duplicates\n\tthis.context = _unique( settings );\n\n\t// Initial data\n\tif ( data ) {\n\t\t$.merge( this, data );\n\t}\n\n\t// selector\n\tthis.selector = {\n\t\trows: null,\n\t\tcols: null,\n\t\topts: null\n\t};\n\n\t_Api.extend( this, this, __apiStruct );\n};\n\nDataTable.Api = _Api;\n\n// Don't destroy the existing prototype, just extend it. Required for jQuery 2's\n// isPlainObject.\n$.extend( _Api.prototype, {\n\tany: function ()\n\t{\n\t\treturn this.count() !== 0;\n\t},\n\n\n\tconcat:  __arrayProto.concat,\n\n\n\tcontext: [], // array of table settings objects\n\n\n\tcount: function ()\n\t{\n\t\treturn this.flatten().length;\n\t},\n\n\n\teach: function ( fn )\n\t{\n\t\tfor ( var i=0, ien=this.length ; i<ien; i++ ) {\n\t\t\tfn.call( this, this[i], i, this );\n\t\t}\n\n\t\treturn this;\n\t},\n\n\n\teq: function ( idx )\n\t{\n\t\tvar ctx = this.context;\n\n\t\treturn ctx.length > idx ?\n\t\t\tnew _Api( ctx[idx], this[idx] ) :\n\t\t\tnull;\n\t},\n\n\n\tfilter: function ( fn )\n\t{\n\t\tvar a = [];\n\n\t\tif ( __arrayProto.filter ) {\n\t\t\ta = __arrayProto.filter.call( this, fn, this );\n\t\t}\n\t\telse {\n\t\t\t// Compatibility for browsers without EMCA-252-5 (JS 1.6)\n\t\t\tfor ( var i=0, ien=this.length ; i<ien ; i++ ) {\n\t\t\t\tif ( fn.call( this, this[i], i, this ) ) {\n\t\t\t\t\ta.push( this[i] );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn new _Api( this.context, a );\n\t},\n\n\n\tflatten: function ()\n\t{\n\t\tvar a = [];\n\t\treturn new _Api( this.context, a.concat.apply( a, this.toArray() ) );\n\t},\n\n\n\tjoin:    __arrayProto.join,\n\n\n\tindexOf: __arrayProto.indexOf || function (obj, start)\n\t{\n\t\tfor ( var i=(start || 0), ien=this.length ; i<ien ; i++ ) {\n\t\t\tif ( this[i] === obj ) {\n\t\t\t\treturn i;\n\t\t\t}\n\t\t}\n\t\treturn -1;\n\t},\n\n\titerator: function ( flatten, type, fn, alwaysNew ) {\n\t\tvar\n\t\t\ta = [], ret,\n\t\t\ti, ien, j, jen,\n\t\t\tcontext = this.context,\n\t\t\trows, items, item,\n\t\t\tselector = this.selector;\n\n\t\t// Argument shifting\n\t\tif ( typeof flatten === 'string' ) {\n\t\t\talwaysNew = fn;\n\t\t\tfn = type;\n\t\t\ttype = flatten;\n\t\t\tflatten = false;\n\t\t}\n\n\t\tfor ( i=0, ien=context.length ; i<ien ; i++ ) {\n\t\t\tvar apiInst = new _Api( context[i] );\n\n\t\t\tif ( type === 'table' ) {\n\t\t\t\tret = fn.call( apiInst, context[i], i );\n\n\t\t\t\tif ( ret !== undefined ) {\n\t\t\t\t\ta.push( ret );\n\t\t\t\t}\n\t\t\t}\n\t\t\telse if ( type === 'columns' || type === 'rows' ) {\n\t\t\t\t// this has same length as context - one entry for each table\n\t\t\t\tret = fn.call( apiInst, context[i], this[i], i );\n\n\t\t\t\tif ( ret !== undefined ) {\n\t\t\t\t\ta.push( ret );\n\t\t\t\t}\n\t\t\t}\n\t\t\telse if ( type === 'column' || type === 'column-rows' || type === 'row' || type === 'cell' ) {\n\t\t\t\t// columns and rows share the same structure.\n\t\t\t\t// 'this' is an array of column indexes for each context\n\t\t\t\titems = this[i];\n\n\t\t\t\tif ( type === 'column-rows' ) {\n\t\t\t\t\trows = _selector_row_indexes( context[i], selector.opts );\n\t\t\t\t}\n\n\t\t\t\tfor ( j=0, jen=items.length ; j<jen ; j++ ) {\n\t\t\t\t\titem = items[j];\n\n\t\t\t\t\tif ( type === 'cell' ) {\n\t\t\t\t\t\tret = fn.call( apiInst, context[i], item.row, item.column, i, j );\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\tret = fn.call( apiInst, context[i], item, i, j, rows );\n\t\t\t\t\t}\n\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}\n\t\t}\n\n\t\tif ( a.length || alwaysNew ) {\n\t\t\tvar api = new _Api( context, flatten ? a.concat.apply( [], a ) : a );\n\t\t\tvar apiSelector = api.selector;\n\t\t\tapiSelector.rows = selector.rows;\n\t\t\tapiSelector.cols = selector.cols;\n\t\t\tapiSelector.opts = selector.opts;\n\t\t\treturn api;\n\t\t}\n\t\treturn this;\n\t},\n\n\n\tlastIndexOf: __arrayProto.lastIndexOf || function (obj, start)\n\t{\n\t\t// Bit cheeky...\n\t\treturn this.indexOf.apply( this.toArray.reverse(), arguments );\n\t},\n\n\n\tlength:  0,\n\n\n\tmap: function ( fn )\n\t{\n\t\tvar a = [];\n\n\t\tif ( __arrayProto.map ) {\n\t\t\ta = __arrayProto.map.call( this, fn, this );\n\t\t}\n\t\telse {\n\t\t\t// Compatibility for browsers without EMCA-252-5 (JS 1.6)\n\t\t\tfor ( var i=0, ien=this.length ; i<ien ; i++ ) {\n\t\t\t\ta.push( fn.call( this, this[i], i ) );\n\t\t\t}\n\t\t}\n\n\t\treturn new _Api( this.context, a );\n\t},\n\n\n\tpluck: function ( prop )\n\t{\n\t\tvar fn = DataTable.util.get(prop);\n\n\t\treturn this.map( function ( el ) {\n\t\t\treturn fn(el);\n\t\t} );\n\t},\n\n\tpop:     __arrayProto.pop,\n\n\n\tpush:    __arrayProto.push,\n\n\n\t// Does not return an API instance\n\treduce: __arrayProto.reduce || function ( fn, init )\n\t{\n\t\treturn _fnReduce( this, fn, init, 0, this.length, 1 );\n\t},\n\n\n\treduceRight: __arrayProto.reduceRight || function ( fn, init )\n\t{\n\t\treturn _fnReduce( this, fn, init, this.length-1, -1, -1 );\n\t},\n\n\n\treverse: __arrayProto.reverse,\n\n\n\t// Object with rows, columns and opts\n\tselector: null,\n\n\n\tshift:   __arrayProto.shift,\n\n\n\tslice: function () {\n\t\treturn new _Api( this.context, this );\n\t},\n\n\n\tsort:    __arrayProto.sort, // ? name - order?\n\n\n\tsplice:  __arrayProto.splice,\n\n\n\ttoArray: function ()\n\t{\n\t\treturn __arrayProto.slice.call( this );\n\t},\n\n\n\tto$: function ()\n\t{\n\t\treturn $( this );\n\t},\n\n\n\ttoJQuery: function ()\n\t{\n\t\treturn $( this );\n\t},\n\n\n\tunique: function ()\n\t{\n\t\treturn new _Api( this.context, _unique(this) );\n\t},\n\n\n\tunshift: __arrayProto.unshift\n} );\n\n\n_Api.extend = function ( scope, obj, ext )\n{\n\t// Only extend API instances and static properties of the API\n\tif ( ! ext.length || ! obj || ( ! (obj instanceof _Api) && ! obj.__dt_wrapper ) ) {\n\t\treturn;\n\t}\n\n\tvar\n\t\ti, ien,\n\t\tstruct,\n\t\tmethodScoping = function ( scope, fn, struc ) {\n\t\t\treturn function () {\n\t\t\t\tvar ret = fn.apply( scope, arguments );\n\n\t\t\t\t// Method extension\n\t\t\t\t_Api.extend( ret, ret, struc.methodExt );\n\t\t\t\treturn ret;\n\t\t\t};\n\t\t};\n\n\tfor ( i=0, ien=ext.length ; i<ien ; i++ ) {\n\t\tstruct = ext[i];\n\n\t\t// Value\n\t\tobj[ struct.name ] = struct.type === 'function' ?\n\t\t\tmethodScoping( scope, struct.val, struct ) :\n\t\t\tstruct.type === 'object' ?\n\t\t\t\t{} :\n\t\t\t\tstruct.val;\n\n\t\tobj[ struct.name ].__dt_wrapper = true;\n\n\t\t// Property extension\n\t\t_Api.extend( scope, obj[ struct.name ], struct.propExt );\n\t}\n};\n\n\n// @todo - Is there need for an augment function?\n// _Api.augment = function ( inst, name )\n// {\n// \t// Find src object in the structure from the name\n// \tvar parts = name.split('.');\n\n// \t_Api.extend( inst, obj );\n// };\n\n\n//     [\n//       {\n//         name:      'data'                -- string   - Property name\n//         val:       function () {},       -- function - Api method (or undefined if just an object\n//         methodExt: [ ... ],              -- array    - Array of Api object definitions to extend the method result\n//         propExt:   [ ... ]               -- array    - Array of Api object definitions to extend the property\n//       },\n//       {\n//         name:     'row'\n//         val:       {},\n//         methodExt: [ ... ],\n//         propExt:   [\n//           {\n//             name:      'data'\n//             val:       function () {},\n//             methodExt: [ ... ],\n//             propExt:   [ ... ]\n//           },\n//           ...\n//         ]\n//       }\n//     ]\n\n_Api.register = _api_register = function ( name, val )\n{\n\tif ( Array.isArray( name ) ) {\n\t\tfor ( var j=0, jen=name.length ; j<jen ; j++ ) {\n\t\t\t_Api.register( name[j], val );\n\t\t}\n\t\treturn;\n\t}\n\n\tvar\n\t\ti, ien,\n\t\their = name.split('.'),\n\t\tstruct = __apiStruct,\n\t\tkey, method;\n\n\tvar find = function ( src, name ) {\n\t\tfor ( var i=0, ien=src.length ; i<ien ; i++ ) {\n\t\t\tif ( src[i].name === name ) {\n\t\t\t\treturn src[i];\n\t\t\t}\n\t\t}\n\t\treturn null;\n\t};\n\n\tfor ( i=0, ien=heir.length ; i<ien ; i++ ) {\n\t\tmethod = heir[i].indexOf('()') !== -1;\n\t\tkey = method ?\n\t\t\their[i].replace('()', '') :\n\t\t\their[i];\n\n\t\tvar src = find( struct, key );\n\t\tif ( ! src ) {\n\t\t\tsrc = {\n\t\t\t\tname:      key,\n\t\t\t\tval:       {},\n\t\t\t\tmethodExt: [],\n\t\t\t\tpropExt:   [],\n\t\t\t\ttype:      'object'\n\t\t\t};\n\t\t\tstruct.push( src );\n\t\t}\n\n\t\tif ( i === ien-1 ) {\n\t\t\tsrc.val = val;\n\t\t\tsrc.type = typeof val === 'function' ?\n\t\t\t\t'function' :\n\t\t\t\t$.isPlainObject( val ) ?\n\t\t\t\t\t'object' :\n\t\t\t\t\t'other';\n\t\t}\n\t\telse {\n\t\t\tstruct = method ?\n\t\t\t\tsrc.methodExt :\n\t\t\t\tsrc.propExt;\n\t\t}\n\t}\n};\n\n_Api.registerPlural = _api_registerPlural = function ( pluralName, singularName, val ) {\n\t_Api.register( pluralName, val );\n\n\t_Api.register( singularName, function () {\n\t\tvar ret = val.apply( this, arguments );\n\n\t\tif ( ret === this ) {\n\t\t\t// Returned item is the API instance that was passed in, return it\n\t\t\treturn this;\n\t\t}\n\t\telse if ( ret instanceof _Api ) {\n\t\t\t// New API instance returned, want the value from the first item\n\t\t\t// in the returned array for the singular result.\n\t\t\treturn ret.length ?\n\t\t\t\tArray.isArray( ret[0] ) ?\n\t\t\t\t\tnew _Api( ret.context, ret[0] ) : // Array results are 'enhanced'\n\t\t\t\t\tret[0] :\n\t\t\t\tundefined;\n\t\t}\n\n\t\t// Non-API return - just fire it back\n\t\treturn ret;\n\t} );\n};\n\n\n/**\n * Selector for HTML tables. Apply the given selector to the give array of\n * DataTables settings objects.\n *\n * @param {string|integer} [selector] jQuery selector string or integer\n * @param  {array} Array of DataTables settings objects to be filtered\n * @return {array}\n * @ignore\n */\nvar __table_selector = function ( selector, a )\n{\n\tif ( Array.isArray(selector) ) {\n\t\treturn $.map( selector, function (item) {\n\t\t\treturn __table_selector(item, a);\n\t\t} );\n\t}\n\n\t// Integer is used to pick out a table by index\n\tif ( typeof selector === 'number' ) {\n\t\treturn [ a[ selector ] ];\n\t}\n\n\t// Perform a jQuery selector on the table nodes\n\tvar nodes = $.map( a, function (el, i) {\n\t\treturn el.nTable;\n\t} );\n\n\treturn $(nodes)\n\t\t.filter( selector )\n\t\t.map( function (i) {\n\t\t\t// Need to translate back from the table node to the settings\n\t\t\tvar idx = $.inArray( this, nodes );\n\t\t\treturn a[ idx ];\n\t\t} )\n\t\t.toArray();\n};\n\n\n\n/**\n * Context selector for the API's context (i.e. the tables the API instance\n * refers to.\n *\n * @name    DataTable.Api#tables\n * @param {string|integer} [selector] Selector to pick which tables the iterator\n *   should operate on. If not given, all tables in the current context are\n *   used. This can be given as a jQuery selector (for example `':gt(0)'`) to\n *   select multiple tables or as an integer to select a single table.\n * @returns {DataTable.Api} Returns a new API instance if a selector is given.\n */\n_api_register( 'tables()', function ( selector ) {\n\t// A new instance is created if there was a selector specified\n\treturn selector !== undefined && selector !== null ?\n\t\tnew _Api( __table_selector( selector, this.context ) ) :\n\t\tthis;\n} );\n\n\n_api_register( 'table()', function ( selector ) {\n\tvar tables = this.tables( selector );\n\tvar ctx = tables.context;\n\n\t// Truncate to the first matched table\n\treturn ctx.length ?\n\t\tnew _Api( ctx[0] ) :\n\t\ttables;\n} );\n\n\n_api_registerPlural( 'tables().nodes()', 'table().node()' , function () {\n\treturn this.iterator( 'table', function ( ctx ) {\n\t\treturn ctx.nTable;\n\t}, 1 );\n} );\n\n\n_api_registerPlural( 'tables().body()', 'table().body()' , function () {\n\treturn this.iterator( 'table', function ( ctx ) {\n\t\treturn ctx.nTBody;\n\t}, 1 );\n} );\n\n\n_api_registerPlural( 'tables().header()', 'table().header()' , function () {\n\treturn this.iterator( 'table', function ( ctx ) {\n\t\treturn ctx.nTHead;\n\t}, 1 );\n} );\n\n\n_api_registerPlural( 'tables().footer()', 'table().footer()' , function () {\n\treturn this.iterator( 'table', function ( ctx ) {\n\t\treturn ctx.nTFoot;\n\t}, 1 );\n} );\n\n\n_api_registerPlural( 'tables().containers()', 'table().container()' , function () {\n\treturn this.iterator( 'table', function ( ctx ) {\n\t\treturn ctx.nTableWrapper;\n\t}, 1 );\n} );\n\n\n\n/**\n * Redraw the tables in the current context.\n */\n_api_register( 'draw()', function ( paging ) {\n\treturn this.iterator( 'table', function ( settings ) {\n\t\tif ( paging === 'page' ) {\n\t\t\t_fnDraw( settings );\n\t\t}\n\t\telse {\n\t\t\tif ( typeof paging === 'string' ) {\n\t\t\t\tpaging = paging === 'full-hold' ?\n\t\t\t\t\tfalse :\n\t\t\t\t\ttrue;\n\t\t\t}\n\n\t\t\t_fnReDraw( settings, paging===false );\n\t\t}\n\t} );\n} );\n\n\n\n/**\n * Get the current page index.\n *\n * @return {integer} Current page index (zero based)\n *//**\n * Set the current page.\n *\n * Note that if you attempt to show a page which does not exist, DataTables will\n * not throw an error, but rather reset the paging.\n *\n * @param {integer|string} action The paging action to take. This can be one of:\n *  * `integer` - The page index to jump to\n *  * `string` - An action to take:\n *    * `first` - Jump to first page.\n *    * `next` - Jump to the next page\n *    * `previous` - Jump to previous page\n *    * `last` - Jump to the last page.\n * @returns {DataTables.Api} this\n */\n_api_register( 'page()', function ( action ) {\n\tif ( action === undefined ) {\n\t\treturn this.page.info().page; // not an expensive call\n\t}\n\n\t// else, have an action to take on all tables\n\treturn this.iterator( 'table', function ( settings ) {\n\t\t_fnPageChange( settings, action );\n\t} );\n} );\n\n\n/**\n * Paging information for the first table in the current context.\n *\n * If you require paging information for another table, use the `table()` method\n * with a suitable selector.\n *\n * @return {object} Object with the following properties set:\n *  * `page` - Current page index (zero based - i.e. the first page is `0`)\n *  * `pages` - Total number of pages\n *  * `start` - Display index for the first record shown on the current page\n *  * `end` - Display index for the last record shown on the current page\n *  * `length` - Display length (number of records). Note that generally `start\n *    + length = end`, but this is not always true, for example if there are\n *    only 2 records to show on the final page, with a length of 10.\n *  * `recordsTotal` - Full data set length\n *  * `recordsDisplay` - Data set length once the current filtering criterion\n *    are applied.\n */\n_api_register( 'page.info()', function ( action ) {\n\tif ( this.context.length === 0 ) {\n\t\treturn undefined;\n\t}\n\n\tvar\n\t\tsettings   = this.context[0],\n\t\tstart      = settings._iDisplayStart,\n\t\tlen        = settings.oFeatures.bPaginate ? settings._iDisplayLength : -1,\n\t\tvisRecords = settings.fnRecordsDisplay(),\n\t\tall        = len === -1;\n\n\treturn {\n\t\t\"page\":           all ? 0 : Math.floor( start / len ),\n\t\t\"pages\":          all ? 1 : Math.ceil( visRecords / len ),\n\t\t\"start\":          start,\n\t\t\"end\":            settings.fnDisplayEnd(),\n\t\t\"length\":         len,\n\t\t\"recordsTotal\":   settings.fnRecordsTotal(),\n\t\t\"recordsDisplay\": visRecords,\n\t\t\"serverSide\":     _fnDataSource( settings ) === 'ssp'\n\t};\n} );\n\n\n/**\n * Get the current page length.\n *\n * @return {integer} Current page length. Note `-1` indicates that all records\n *   are to be shown.\n *//**\n * Set the current page length.\n *\n * @param {integer} Page length to set. Use `-1` to show all records.\n * @returns {DataTables.Api} this\n */\n_api_register( 'page.len()', function ( len ) {\n\t// Note that we can't call this function 'length()' because `length`\n\t// is a Javascript property of functions which defines how many arguments\n\t// the function expects.\n\tif ( len === undefined ) {\n\t\treturn this.context.length !== 0 ?\n\t\t\tthis.context[0]._iDisplayLength :\n\t\t\tundefined;\n\t}\n\n\t// else, set the page length\n\treturn this.iterator( 'table', function ( settings ) {\n\t\t_fnLengthChange( settings, len );\n\t} );\n} );\n\n\n\nvar __reload = function ( settings, holdPosition, callback ) {\n\t// Use the draw event to trigger a callback\n\tif ( callback ) {\n\t\tvar api = new _Api( settings );\n\n\t\tapi.one( 'draw', function () {\n\t\t\tcallback( api.ajax.json() );\n\t\t} );\n\t}\n\n\tif ( _fnDataSource( settings ) == 'ssp' ) {\n\t\t_fnReDraw( settings, holdPosition );\n\t}\n\telse {\n\t\t_fnProcessingDisplay( settings, true );\n\n\t\t// Cancel an existing request\n\t\tvar xhr = settings.jqXHR;\n\t\tif ( xhr && xhr.readyState !== 4 ) {\n\t\t\txhr.abort();\n\t\t}\n\n\t\t// Trigger xhr\n\t\t_fnBuildAjax( settings, [], function( json ) {\n\t\t\t_fnClearTable( settings );\n\n\t\t\tvar data = _fnAjaxDataSrc( settings, json );\n\t\t\tfor ( var i=0, ien=data.length ; i<ien ; i++ ) {\n\t\t\t\t_fnAddData( settings, data[i] );\n\t\t\t}\n\n\t\t\t_fnReDraw( settings, holdPosition );\n\t\t\t_fnProcessingDisplay( settings, false );\n\t\t} );\n\t}\n};\n\n\n/**\n * Get the JSON response from the last Ajax request that DataTables made to the\n * server. Note that this returns the JSON from the first table in the current\n * context.\n *\n * @return {object} JSON received from the server.\n */\n_api_register( 'ajax.json()', function () {\n\tvar ctx = this.context;\n\n\tif ( ctx.length > 0 ) {\n\t\treturn ctx[0].json;\n\t}\n\n\t// else return undefined;\n} );\n\n\n/**\n * Get the data submitted in the last Ajax request\n */\n_api_register( 'ajax.params()', function () {\n\tvar ctx = this.context;\n\n\tif ( ctx.length > 0 ) {\n\t\treturn ctx[0].oAjaxData;\n\t}\n\n\t// else return undefined;\n} );\n\n\n/**\n * Reload tables from the Ajax data source. Note that this function will\n * automatically re-draw the table when the remote data has been loaded.\n *\n * @param {boolean} [reset=true] Reset (default) or hold the current paging\n *   position. A full re-sort and re-filter is performed when this method is\n *   called, which is why the pagination reset is the default action.\n * @returns {DataTables.Api} this\n */\n_api_register( 'ajax.reload()', function ( callback, resetPaging ) {\n\treturn this.iterator( 'table', function (settings) {\n\t\t__reload( settings, resetPaging===false, callback );\n\t} );\n} );\n\n\n/**\n * Get the current Ajax URL. Note that this returns the URL from the first\n * table in the current context.\n *\n * @return {string} Current Ajax source URL\n *//**\n * Set the Ajax URL. Note that this will set the URL for all tables in the\n * current context.\n *\n * @param {string} url URL to set.\n * @returns {DataTables.Api} this\n */\n_api_register( 'ajax.url()', function ( url ) {\n\tvar ctx = this.context;\n\n\tif ( url === undefined ) {\n\t\t// get\n\t\tif ( ctx.length === 0 ) {\n\t\t\treturn undefined;\n\t\t}\n\t\tctx = ctx[0];\n\n\t\treturn ctx.ajax ?\n\t\t\t$.isPlainObject( ctx.ajax ) ?\n\t\t\t\tctx.ajax.url :\n\t\t\t\tctx.ajax :\n\t\t\tctx.sAjaxSource;\n\t}\n\n\t// set\n\treturn this.iterator( 'table', function ( settings ) {\n\t\tif ( $.isPlainObject( settings.ajax ) ) {\n\t\t\tsettings.ajax.url = url;\n\t\t}\n\t\telse {\n\t\t\tsettings.ajax = url;\n\t\t}\n\t\t// No need to consider sAjaxSource here since DataTables gives priority\n\t\t// to `ajax` over `sAjaxSource`. So setting `ajax` here, renders any\n\t\t// value of `sAjaxSource` redundant.\n\t} );\n} );\n\n\n/**\n * Load data from the newly set Ajax URL. Note that this method is only\n * available when `ajax.url()` is used to set a URL. Additionally, this method\n * has the same effect as calling `ajax.reload()` but is provided for\n * convenience when setting a new URL. Like `ajax.reload()` it will\n * automatically redraw the table once the remote data has been loaded.\n *\n * @returns {DataTables.Api} this\n */\n_api_register( 'ajax.url().load()', function ( callback, resetPaging ) {\n\t// Same as a reload, but makes sense to present it for easy access after a\n\t// url change\n\treturn this.iterator( 'table', function ( ctx ) {\n\t\t__reload( ctx, resetPaging===false, callback );\n\t} );\n} );\n\n\n\n\nvar _selector_run = function ( type, selector, selectFn, settings, opts )\n{\n\tvar\n\t\tout = [], res,\n\t\ta, i, ien, j, jen,\n\t\tselectorType = typeof selector;\n\n\t// Can't just check for isArray here, as an API or jQuery instance might be\n\t// given with their array like look\n\tif ( ! selector || selectorType === 'string' || selectorType === 'function' || selector.length === undefined ) {\n\t\tselector = [ selector ];\n\t}\n\n\tfor ( i=0, ien=selector.length ; i<ien ; i++ ) {\n\t\t// Only split on simple strings - complex expressions will be jQuery selectors\n\t\ta = selector[i] && selector[i].split && ! selector[i].match(/[\\[\\(:]/) ?\n\t\t\tselector[i].split(',') :\n\t\t\t[ selector[i] ];\n\n\t\tfor ( j=0, jen=a.length ; j<jen ; j++ ) {\n\t\t\tres = selectFn( typeof a[j] === 'string' ? (a[j]).trim() : a[j] );\n\n\t\t\tif ( res && res.length ) {\n\t\t\t\tout = out.concat( res );\n\t\t\t}\n\t\t}\n\t}\n\n\t// selector extensions\n\tvar ext = _ext.selector[ type ];\n\tif ( ext.length ) {\n\t\tfor ( i=0, ien=ext.length ; i<ien ; i++ ) {\n\t\t\tout = ext[i]( settings, opts, out );\n\t\t}\n\t}\n\n\treturn _unique( out );\n};\n\n\nvar _selector_opts = function ( opts )\n{\n\tif ( ! opts ) {\n\t\topts = {};\n\t}\n\n\t// Backwards compatibility for 1.9- which used the terminology filter rather\n\t// than search\n\tif ( opts.filter && opts.search === undefined ) {\n\t\topts.search = opts.filter;\n\t}\n\n\treturn $.extend( {\n\t\tsearch: 'none',\n\t\torder: 'current',\n\t\tpage: 'all'\n\t}, opts );\n};\n\n\nvar _selector_first = function ( inst )\n{\n\t// Reduce the API instance to the first item found\n\tfor ( var i=0, ien=inst.length ; i<ien ; i++ ) {\n\t\tif ( inst[i].length > 0 ) {\n\t\t\t// Assign the first element to the first item in the instance\n\t\t\t// and truncate the instance and context\n\t\t\tinst[0] = inst[i];\n\t\t\tinst[0].length = 1;\n\t\t\tinst.length = 1;\n\t\t\tinst.context = [ inst.context[i] ];\n\n\t\t\treturn inst;\n\t\t}\n\t}\n\n\t// Not found - return an empty instance\n\tinst.length = 0;\n\treturn inst;\n};\n\n\nvar _selector_row_indexes = function ( settings, opts )\n{\n\tvar\n\t\ti, ien, tmp, a=[],\n\t\tdisplayFiltered = settings.aiDisplay,\n\t\tdisplayMaster = settings.aiDisplayMaster;\n\n\tvar\n\t\tsearch = opts.search,  // none, applied, removed\n\t\torder  = opts.order,   // applied, current, index (original - compatibility with 1.9)\n\t\tpage   = opts.page;    // all, current\n\n\tif ( _fnDataSource( settings ) == 'ssp' ) {\n\t\t// In server-side processing mode, most options are irrelevant since\n\t\t// rows not shown don't exist and the index order is the applied order\n\t\t// Removed is a special case - for consistency just return an empty\n\t\t// array\n\t\treturn search === 'removed' ?\n\t\t\t[] :\n\t\t\t_range( 0, displayMaster.length );\n\t}\n\telse if ( page == 'current' ) {\n\t\t// Current page implies that order=current and filter=applied, since it is\n\t\t// fairly senseless otherwise, regardless of what order and search actually\n\t\t// are\n\t\tfor ( i=settings._iDisplayStart, ien=settings.fnDisplayEnd() ; i<ien ; i++ ) {\n\t\t\ta.push( displayFiltered[i] );\n\t\t}\n\t}\n\telse if ( order == 'current' || order == 'applied' ) {\n\t\tif ( search == 'none') {\n\t\t\ta = displayMaster.slice();\n\t\t}\n\t\telse if ( search == 'applied' ) {\n\t\t\ta = displayFiltered.slice();\n\t\t}\n\t\telse if ( search == 'removed' ) {\n\t\t\t// O(n+m) solution by creating a hash map\n\t\t\tvar displayFilteredMap = {};\n\n\t\t\tfor ( var i=0, ien=displayFiltered.length ; i<ien ; i++ ) {\n\t\t\t\tdisplayFilteredMap[displayFiltered[i]] = null;\n\t\t\t}\n\n\t\t\ta = $.map( displayMaster, function (el) {\n\t\t\t\treturn ! displayFilteredMap.hasOwnProperty(el) ?\n\t\t\t\t\tel :\n\t\t\t\t\tnull;\n\t\t\t} );\n\t\t}\n\t}\n\telse if ( order == 'index' || order == 'original' ) {\n\t\tfor ( i=0, ien=settings.aoData.length ; i<ien ; i++ ) {\n\t\t\tif ( search == 'none' ) {\n\t\t\t\ta.push( i );\n\t\t\t}\n\t\t\telse { // applied | removed\n\t\t\t\ttmp = $.inArray( i, displayFiltered );\n\n\t\t\t\tif ((tmp === -1 && search == 'removed') ||\n\t\t\t\t\t(tmp >= 0   && search == 'applied') )\n\t\t\t\t{\n\t\t\t\t\ta.push( i );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn a;\n};\n\n\n/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n * Rows\n *\n * {}          - no selector - use all available rows\n * {integer}   - row aoData index\n * {node}      - TR node\n * {string}    - jQuery selector to apply to the TR elements\n * {array}     - jQuery array of nodes, or simply an array of TR nodes\n *\n */\nvar __row_selector = function ( settings, selector, opts )\n{\n\tvar rows;\n\tvar run = function ( sel ) {\n\t\tvar selInt = _intVal( sel );\n\t\tvar i, ien;\n\t\tvar aoData = settings.aoData;\n\n\t\t// Short cut - selector is a number and no options provided (default is\n\t\t// all records, so no need to check if the index is in there, since it\n\t\t// must be - dev error if the index doesn't exist).\n\t\tif ( selInt !== null && ! opts ) {\n\t\t\treturn [ selInt ];\n\t\t}\n\n\t\tif ( ! rows ) {\n\t\t\trows = _selector_row_indexes( settings, opts );\n\t\t}\n\n\t\tif ( selInt !== null && $.inArray( selInt, rows ) !== -1 ) {\n\t\t\t// Selector - integer\n\t\t\treturn [ selInt ];\n\t\t}\n\t\telse if ( sel === null || sel === undefined || sel === '' ) {\n\t\t\t// Selector - none\n\t\t\treturn rows;\n\t\t}\n\n\t\t// Selector - function\n\t\tif ( typeof sel === 'function' ) {\n\t\t\treturn $.map( rows, function (idx) {\n\t\t\t\tvar row = aoData[ idx ];\n\t\t\t\treturn sel( idx, row._aData, row.nTr ) ? idx : null;\n\t\t\t} );\n\t\t}\n\n\t\t// Selector - node\n\t\tif ( sel.nodeName ) {\n\t\t\tvar rowIdx = sel._DT_RowIndex;  // Property added by DT for fast lookup\n\t\t\tvar cellIdx = sel._DT_CellIndex;\n\n\t\t\tif ( rowIdx !== undefined ) {\n\t\t\t\t// Make sure that the row is actually still present in the table\n\t\t\t\treturn aoData[ rowIdx ] && aoData[ rowIdx ].nTr === sel ?\n\t\t\t\t\t[ rowIdx ] :\n\t\t\t\t\t[];\n\t\t\t}\n\t\t\telse if ( cellIdx ) {\n\t\t\t\treturn aoData[ cellIdx.row ] && aoData[ cellIdx.row ].nTr === sel.parentNode ?\n\t\t\t\t\t[ cellIdx.row ] :\n\t\t\t\t\t[];\n\t\t\t}\n\t\t\telse {\n\t\t\t\tvar host = $(sel).closest('*[data-dt-row]');\n\t\t\t\treturn host.length ?\n\t\t\t\t\t[ host.data('dt-row') ] :\n\t\t\t\t\t[];\n\t\t\t}\n\t\t}\n\n\t\t// ID selector. Want to always be able to select rows by id, regardless\n\t\t// of if the tr element has been created or not, so can't rely upon\n\t\t// jQuery here - hence a custom implementation. This does not match\n\t\t// Sizzle's fast selector or HTML4 - in HTML5 the ID can be anything,\n\t\t// but to select it using a CSS selector engine (like Sizzle or\n\t\t// querySelect) it would need to need to be escaped for some characters.\n\t\t// DataTables simplifies this for row selectors since you can select\n\t\t// only a row. A # indicates an id any anything that follows is the id -\n\t\t// unescaped.\n\t\tif ( typeof sel === 'string' && sel.charAt(0) === '#' ) {\n\t\t\t// get row index from id\n\t\t\tvar rowObj = settings.aIds[ sel.replace( /^#/, '' ) ];\n\t\t\tif ( rowObj !== undefined ) {\n\t\t\t\treturn [ rowObj.idx ];\n\t\t\t}\n\n\t\t\t// need to fall through to jQuery in case there is DOM id that\n\t\t\t// matches\n\t\t}\n\t\t\n\t\t// Get nodes in the order from the `rows` array with null values removed\n\t\tvar nodes = _removeEmpty(\n\t\t\t_pluck_order( settings.aoData, rows, 'nTr' )\n\t\t);\n\n\t\t// Selector - jQuery selector string, array of nodes or jQuery object/\n\t\t// As jQuery's .filter() allows jQuery objects to be passed in filter,\n\t\t// it also allows arrays, so this will cope with all three options\n\t\treturn $(nodes)\n\t\t\t.filter( sel )\n\t\t\t.map( function () {\n\t\t\t\treturn this._DT_RowIndex;\n\t\t\t} )\n\t\t\t.toArray();\n\t};\n\n\treturn _selector_run( 'row', selector, run, settings, opts );\n};\n\n\n_api_register( 'rows()', function ( selector, opts ) {\n\t// argument shifting\n\tif ( selector === undefined ) {\n\t\tselector = '';\n\t}\n\telse if ( $.isPlainObject( selector ) ) {\n\t\topts = selector;\n\t\tselector = '';\n\t}\n\n\topts = _selector_opts( opts );\n\n\tvar inst = this.iterator( 'table', function ( settings ) {\n\t\treturn __row_selector( settings, selector, opts );\n\t}, 1 );\n\n\t// Want argument shifting here and in __row_selector?\n\tinst.selector.rows = selector;\n\tinst.selector.opts = opts;\n\n\treturn inst;\n} );\n\n_api_register( 'rows().nodes()', function () {\n\treturn this.iterator( 'row', function ( settings, row ) {\n\t\treturn settings.aoData[ row ].nTr || undefined;\n\t}, 1 );\n} );\n\n_api_register( 'rows().data()', function () {\n\treturn this.iterator( true, 'rows', function ( settings, rows ) {\n\t\treturn _pluck_order( settings.aoData, rows, '_aData' );\n\t}, 1 );\n} );\n\n_api_registerPlural( 'rows().cache()', 'row().cache()', function ( type ) {\n\treturn this.iterator( 'row', function ( settings, row ) {\n\t\tvar r = settings.aoData[ row ];\n\t\treturn type === 'search' ? r._aFilterData : r._aSortData;\n\t}, 1 );\n} );\n\n_api_registerPlural( 'rows().invalidate()', 'row().invalidate()', function ( src ) {\n\treturn this.iterator( 'row', function ( settings, row ) {\n\t\t_fnInvalidate( settings, row, src );\n\t} );\n} );\n\n_api_registerPlural( 'rows().indexes()', 'row().index()', function () {\n\treturn this.iterator( 'row', function ( settings, row ) {\n\t\treturn row;\n\t}, 1 );\n} );\n\n_api_registerPlural( 'rows().ids()', 'row().id()', function ( hash ) {\n\tvar a = [];\n\tvar context = this.context;\n\n\t// `iterator` will drop undefined values, but in this case we want them\n\tfor ( var i=0, ien=context.length ; i<ien ; i++ ) {\n\t\tfor ( var j=0, jen=this[i].length ; j<jen ; j++ ) {\n\t\t\tvar id = context[i].rowIdFn( context[i].aoData[ this[i][j] ]._aData );\n\t\t\ta.push( (hash === true ? '#' : '' )+ id );\n\t\t}\n\t}\n\n\treturn new _Api( context, a );\n} );\n\n_api_registerPlural( 'rows().remove()', 'row().remove()', function () {\n\tvar that = this;\n\n\tthis.iterator( 'row', function ( settings, row, thatIdx ) {\n\t\tvar data = settings.aoData;\n\t\tvar rowData = data[ row ];\n\t\tvar i, ien, j, jen;\n\t\tvar loopRow, loopCells;\n\n\t\tdata.splice( row, 1 );\n\n\t\t// Update the cached indexes\n\t\tfor ( i=0, ien=data.length ; i<ien ; i++ ) {\n\t\t\tloopRow = data[i];\n\t\t\tloopCells = loopRow.anCells;\n\n\t\t\t// Rows\n\t\t\tif ( loopRow.nTr !== null ) {\n\t\t\t\tloopRow.nTr._DT_RowIndex = i;\n\t\t\t}\n\n\t\t\t// Cells\n\t\t\tif ( loopCells !== null ) {\n\t\t\t\tfor ( j=0, jen=loopCells.length ; j<jen ; j++ ) {\n\t\t\t\t\tloopCells[j]._DT_CellIndex.row = i;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Delete from the display arrays\n\t\t_fnDeleteIndex( settings.aiDisplayMaster, row );\n\t\t_fnDeleteIndex( settings.aiDisplay, row );\n\t\t_fnDeleteIndex( that[ thatIdx ], row, false ); // maintain local indexes\n\n\t\t// For server-side processing tables - subtract the deleted row from the count\n\t\tif ( settings._iRecordsDisplay > 0 ) {\n\t\t\tsettings._iRecordsDisplay--;\n\t\t}\n\n\t\t// Check for an 'overflow' they case for displaying the table\n\t\t_fnLengthOverflow( settings );\n\n\t\t// Remove the row's ID reference if there is one\n\t\tvar id = settings.rowIdFn( rowData._aData );\n\t\tif ( id !== undefined ) {\n\t\t\tdelete settings.aIds[ id ];\n\t\t}\n\t} );\n\n\tthis.iterator( 'table', function ( settings ) {\n\t\tfor ( var i=0, ien=settings.aoData.length ; i<ien ; i++ ) {\n\t\t\tsettings.aoData[i].idx = i;\n\t\t}\n\t} );\n\n\treturn this;\n} );\n\n\n_api_register( 'rows.add()', function ( rows ) {\n\tvar newRows = this.iterator( 'table', function ( settings ) {\n\t\t\tvar row, i, ien;\n\t\t\tvar out = [];\n\n\t\t\tfor ( i=0, ien=rows.length ; i<ien ; i++ ) {\n\t\t\t\trow = rows[i];\n\n\t\t\t\tif ( row.nodeName && row.nodeName.toUpperCase() === 'TR' ) {\n\t\t\t\t\tout.push( _fnAddTr( settings, row )[0] );\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tout.push( _fnAddData( settings, row ) );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn out;\n\t\t}, 1 );\n\n\t// Return an Api.rows() extended instance, so rows().nodes() etc can be used\n\tvar modRows = this.rows( -1 );\n\tmodRows.pop();\n\t$.merge( modRows, newRows );\n\n\treturn modRows;\n} );\n\n\n\n\n\n/**\n *\n */\n_api_register( 'row()', function ( selector, opts ) {\n\treturn _selector_first( this.rows( selector, opts ) );\n} );\n\n\n_api_register( 'row().data()', function ( data ) {\n\tvar ctx = this.context;\n\n\tif ( data === undefined ) {\n\t\t// Get\n\t\treturn ctx.length && this.length ?\n\t\t\tctx[0].aoData[ this[0] ]._aData :\n\t\t\tundefined;\n\t}\n\n\t// Set\n\tvar row = ctx[0].aoData[ this[0] ];\n\trow._aData = data;\n\n\t// If the DOM has an id, and the data source is an array\n\tif ( Array.isArray( data ) && row.nTr && row.nTr.id ) {\n\t\t_fnSetObjectDataFn( ctx[0].rowId )( data, row.nTr.id );\n\t}\n\n\t// Automatically invalidate\n\t_fnInvalidate( ctx[0], this[0], 'data' );\n\n\treturn this;\n} );\n\n\n_api_register( 'row().node()', function () {\n\tvar ctx = this.context;\n\n\treturn ctx.length && this.length ?\n\t\tctx[0].aoData[ this[0] ].nTr || null :\n\t\tnull;\n} );\n\n\n_api_register( 'row.add()', function ( row ) {\n\t// Allow a jQuery object to be passed in - only a single row is added from\n\t// it though - the first element in the set\n\tif ( row instanceof $ && row.length ) {\n\t\trow = row[0];\n\t}\n\n\tvar rows = this.iterator( 'table', function ( settings ) {\n\t\tif ( row.nodeName && row.nodeName.toUpperCase() === 'TR' ) {\n\t\t\treturn _fnAddTr( settings, row )[0];\n\t\t}\n\t\treturn _fnAddData( settings, row );\n\t} );\n\n\t// Return an Api.rows() extended instance, with the newly added row selected\n\treturn this.row( rows[0] );\n} );\n\n\n$(document).on('plugin-init.dt', function (e, context) {\n\tvar api = new _Api( context );\n\tvar namespace = 'on-plugin-init';\n\tvar stateSaveParamsEvent = 'stateSaveParams.' + namespace;\n\tvar destroyEvent = 'destroy. ' + namespace;\n\n\tapi.on( stateSaveParamsEvent, function ( e, settings, d ) {\n\t\t// This could be more compact with the API, but it is a lot faster as a simple\n\t\t// internal loop\n\t\tvar idFn = settings.rowIdFn;\n\t\tvar data = settings.aoData;\n\t\tvar ids = [];\n\n\t\tfor (var i=0 ; i<data.length ; i++) {\n\t\t\tif (data[i]._detailsShow) {\n\t\t\t\tids.push( '#' + idFn(data[i]._aData) );\n\t\t\t}\n\t\t}\n\n\t\td.childRows = ids;\n\t});\n\n\tapi.on( destroyEvent, function () {\n\t\tapi.off(stateSaveParamsEvent + ' ' + destroyEvent);\n\t});\n\n\tvar loaded = api.state.loaded();\n\n\tif ( loaded && loaded.childRows ) {\n\t\tapi\n\t\t\t.rows( $.map(loaded.childRows, function (id){\n\t\t\t\treturn id.replace(/:/g, '\\\\:')\n\t\t\t}) )\n\t\t\t.every( function () {\n\t\t\t\t_fnCallbackFire( context, null, 'requestChild', [ this ] )\n\t\t\t});\n\t}\n});\n\nvar __details_add = function ( ctx, row, data, klass )\n{\n\t// Convert to array of TR elements\n\tvar rows = [];\n\tvar addRow = function ( r, k ) {\n\t\t// Recursion to allow for arrays of jQuery objects\n\t\tif ( Array.isArray( r ) || r instanceof $ ) {\n\t\t\tfor ( var i=0, ien=r.length ; i<ien ; i++ ) {\n\t\t\t\taddRow( r[i], k );\n\t\t\t}\n\t\t\treturn;\n\t\t}\n\n\t\t// If we get a TR element, then just add it directly - up to the dev\n\t\t// to add the correct number of columns etc\n\t\tif ( r.nodeName && r.nodeName.toLowerCase() === 'tr' ) {\n\t\t\trows.push( r );\n\t\t}\n\t\telse {\n\t\t\t// Otherwise create a row with a wrapper\n\t\t\tvar created = $('<tr><td></td></tr>').addClass( k );\n\t\t\t$('td', created)\n\t\t\t\t.addClass( k )\n\t\t\t\t.html( r )\n\t\t\t\t[0].colSpan = _fnVisbleColumns( ctx );\n\n\t\t\trows.push( created[0] );\n\t\t}\n\t};\n\n\taddRow( data, klass );\n\n\tif ( row._details ) {\n\t\trow._details.detach();\n\t}\n\n\trow._details = $(rows);\n\n\t// If the children were already shown, that state should be retained\n\tif ( row._detailsShow ) {\n\t\trow._details.insertAfter( row.nTr );\n\t}\n};\n\n\n// Make state saving of child row details async to allow them to be batch processed\nvar __details_state = DataTable.util.throttle(\n\tfunction (ctx) {\n\t\t_fnSaveState( ctx[0] )\n\t},\n\t500\n);\n\n\nvar __details_remove = function ( api, idx )\n{\n\tvar ctx = api.context;\n\n\tif ( ctx.length ) {\n\t\tvar row = ctx[0].aoData[ idx !== undefined ? idx : api[0] ];\n\n\t\tif ( row && row._details ) {\n\t\t\trow._details.remove();\n\n\t\t\trow._detailsShow = undefined;\n\t\t\trow._details = undefined;\n\t\t\t$( row.nTr ).removeClass( 'dt-hasChild' );\n\t\t\t__details_state( ctx );\n\t\t}\n\t}\n};\n\n\nvar __details_display = function ( api, show ) {\n\tvar ctx = api.context;\n\n\tif ( ctx.length && api.length ) {\n\t\tvar row = ctx[0].aoData[ api[0] ];\n\n\t\tif ( row._details ) {\n\t\t\trow._detailsShow = show;\n\n\t\t\tif ( show ) {\n\t\t\t\trow._details.insertAfter( row.nTr );\n\t\t\t\t$( row.nTr ).addClass( 'dt-hasChild' );\n\t\t\t}\n\t\t\telse {\n\t\t\t\trow._details.detach();\n\t\t\t\t$( row.nTr ).removeClass( 'dt-hasChild' );\n\t\t\t}\n\n\t\t\t_fnCallbackFire( ctx[0], null, 'childRow', [ show, api.row( api[0] ) ] )\n\n\t\t\t__details_events( ctx[0] );\n\t\t\t__details_state( ctx );\n\t\t}\n\t}\n};\n\n\nvar __details_events = function ( settings )\n{\n\tvar api = new _Api( settings );\n\tvar namespace = '.dt.DT_details';\n\tvar drawEvent = 'draw'+namespace;\n\tvar colvisEvent = 'column-sizing'+namespace;\n\tvar destroyEvent = 'destroy'+namespace;\n\tvar data = settings.aoData;\n\n\tapi.off( drawEvent +' '+ colvisEvent +' '+ destroyEvent );\n\n\tif ( _pluck( data, '_details' ).length > 0 ) {\n\t\t// On each draw, insert the required elements into the document\n\t\tapi.on( drawEvent, function ( e, ctx ) {\n\t\t\tif ( settings !== ctx ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tapi.rows( {page:'current'} ).eq(0).each( function (idx) {\n\t\t\t\t// Internal data grab\n\t\t\t\tvar row = data[ idx ];\n\n\t\t\t\tif ( row._detailsShow ) {\n\t\t\t\t\trow._details.insertAfter( row.nTr );\n\t\t\t\t}\n\t\t\t} );\n\t\t} );\n\n\t\t// Column visibility change - update the colspan\n\t\tapi.on( colvisEvent, function ( e, ctx, idx, vis ) {\n\t\t\tif ( settings !== ctx ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Update the colspan for the details rows (note, only if it already has\n\t\t\t// a colspan)\n\t\t\tvar row, visible = _fnVisbleColumns( ctx );\n\n\t\t\tfor ( var i=0, ien=data.length ; i<ien ; i++ ) {\n\t\t\t\trow = data[i];\n\n\t\t\t\tif ( row._details ) {\n\t\t\t\t\trow._details.each(function () {\n\t\t\t\t\t\tvar el = $(this).children('td');\n\n\t\t\t\t\t\tif (el.length == 1) {\n\t\t\t\t\t\t\tel.attr('colspan', visible);\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\n\t\t// Table destroyed - nuke any child rows\n\t\tapi.on( destroyEvent, function ( e, ctx ) {\n\t\t\tif ( settings !== ctx ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tfor ( var i=0, ien=data.length ; i<ien ; i++ ) {\n\t\t\t\tif ( data[i]._details ) {\n\t\t\t\t\t__details_remove( api, i );\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t}\n};\n\n// Strings for the method names to help minification\nvar _emp = '';\nvar _child_obj = _emp+'row().child';\nvar _child_mth = _child_obj+'()';\n\n// data can be:\n//  tr\n//  string\n//  jQuery or array of any of the above\n_api_register( _child_mth, function ( data, klass ) {\n\tvar ctx = this.context;\n\n\tif ( data === undefined ) {\n\t\t// get\n\t\treturn ctx.length && this.length ?\n\t\t\tctx[0].aoData[ this[0] ]._details :\n\t\t\tundefined;\n\t}\n\telse if ( data === true ) {\n\t\t// show\n\t\tthis.child.show();\n\t}\n\telse if ( data === false ) {\n\t\t// remove\n\t\t__details_remove( this );\n\t}\n\telse if ( ctx.length && this.length ) {\n\t\t// set\n\t\t__details_add( ctx[0], ctx[0].aoData[ this[0] ], data, klass );\n\t}\n\n\treturn this;\n} );\n\n\n_api_register( [\n\t_child_obj+'.show()',\n\t_child_mth+'.show()' // only when `child()` was called with parameters (without\n], function ( show ) {   // it returns an object and this method is not executed)\n\t__details_display( this, true );\n\treturn this;\n} );\n\n\n_api_register( [\n\t_child_obj+'.hide()',\n\t_child_mth+'.hide()' // only when `child()` was called with parameters (without\n], function () {         // it returns an object and this method is not executed)\n\t__details_display( this, false );\n\treturn this;\n} );\n\n\n_api_register( [\n\t_child_obj+'.remove()',\n\t_child_mth+'.remove()' // only when `child()` was called with parameters (without\n], function () {           // it returns an object and this method is not executed)\n\t__details_remove( this );\n\treturn this;\n} );\n\n\n_api_register( _child_obj+'.isShown()', function () {\n\tvar ctx = this.context;\n\n\tif ( ctx.length && this.length ) {\n\t\t// _detailsShown as false or undefined will fall through to return false\n\t\treturn ctx[0].aoData[ this[0] ]._detailsShow || false;\n\t}\n\treturn false;\n} );\n\n\n\n/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n * Columns\n *\n * {integer}           - column index (>=0 count from left, <0 count from right)\n * \"{integer}:visIdx\"  - visible column index (i.e. translate to column index)  (>=0 count from left, <0 count from right)\n * \"{integer}:visible\" - alias for {integer}:visIdx  (>=0 count from left, <0 count from right)\n * \"{string}:name\"     - column name\n * \"{string}\"          - jQuery selector on column header nodes\n *\n */\n\n// can be an array of these items, comma separated list, or an array of comma\n// separated lists\n\nvar __re_column_selector = /^([^:]+):(name|visIdx|visible)$/;\n\n\n// r1 and r2 are redundant - but it means that the parameters match for the\n// iterator callback in columns().data()\nvar __columnData = function ( settings, column, r1, r2, rows ) {\n\tvar a = [];\n\tfor ( var row=0, ien=rows.length ; row<ien ; row++ ) {\n\t\ta.push( _fnGetCellData( settings, rows[row], column ) );\n\t}\n\treturn a;\n};\n\n\nvar __column_selector = function ( settings, selector, opts )\n{\n\tvar\n\t\tcolumns = settings.aoColumns,\n\t\tnames = _pluck( columns, 'sName' ),\n\t\tnodes = _pluck( columns, 'nTh' );\n\n\tvar run = function ( s ) {\n\t\tvar selInt = _intVal( s );\n\n\t\t// Selector - all\n\t\tif ( s === '' ) {\n\t\t\treturn _range( columns.length );\n\t\t}\n\n\t\t// Selector - index\n\t\tif ( selInt !== null ) {\n\t\t\treturn [ selInt >= 0 ?\n\t\t\t\tselInt : // Count from left\n\t\t\t\tcolumns.length + selInt // Count from right (+ because its a negative value)\n\t\t\t];\n\t\t}\n\n\t\t// Selector = function\n\t\tif ( typeof s === 'function' ) {\n\t\t\tvar rows = _selector_row_indexes( settings, opts );\n\n\t\t\treturn $.map( columns, function (col, idx) {\n\t\t\t\treturn s(\n\t\t\t\t\t\tidx,\n\t\t\t\t\t\t__columnData( settings, idx, 0, 0, rows ),\n\t\t\t\t\t\tnodes[ idx ]\n\t\t\t\t\t) ? idx : null;\n\t\t\t} );\n\t\t}\n\n\t\t// jQuery or string selector\n\t\tvar match = typeof s === 'string' ?\n\t\t\ts.match( __re_column_selector ) :\n\t\t\t'';\n\n\t\tif ( match ) {\n\t\t\tswitch( match[2] ) {\n\t\t\t\tcase 'visIdx':\n\t\t\t\tcase 'visible':\n\t\t\t\t\tvar idx = parseInt( match[1], 10 );\n\t\t\t\t\t// Visible index given, convert to column index\n\t\t\t\t\tif ( idx < 0 ) {\n\t\t\t\t\t\t// Counting from the right\n\t\t\t\t\t\tvar visColumns = $.map( columns, function (col,i) {\n\t\t\t\t\t\t\treturn col.bVisible ? i : null;\n\t\t\t\t\t\t} );\n\t\t\t\t\t\treturn [ visColumns[ visColumns.length + idx ] ];\n\t\t\t\t\t}\n\t\t\t\t\t// Counting from the left\n\t\t\t\t\treturn [ _fnVisibleToColumnIndex( settings, idx ) ];\n\n\t\t\t\tcase 'name':\n\t\t\t\t\t// match by name. `names` is column index complete and in order\n\t\t\t\t\treturn $.map( names, function (name, i) {\n\t\t\t\t\t\treturn name === match[1] ? i : null;\n\t\t\t\t\t} );\n\n\t\t\t\tdefault:\n\t\t\t\t\treturn [];\n\t\t\t}\n\t\t}\n\n\t\t// Cell in the table body\n\t\tif ( s.nodeName && s._DT_CellIndex ) {\n\t\t\treturn [ s._DT_CellIndex.column ];\n\t\t}\n\n\t\t// jQuery selector on the TH elements for the columns\n\t\tvar jqResult = $( nodes )\n\t\t\t.filter( s )\n\t\t\t.map( function () {\n\t\t\t\treturn $.inArray( this, nodes ); // `nodes` is column index complete and in order\n\t\t\t} )\n\t\t\t.toArray();\n\n\t\tif ( jqResult.length || ! s.nodeName ) {\n\t\t\treturn jqResult;\n\t\t}\n\n\t\t// Otherwise a node which might have a `dt-column` data attribute, or be\n\t\t// a child or such an element\n\t\tvar host = $(s).closest('*[data-dt-column]');\n\t\treturn host.length ?\n\t\t\t[ host.data('dt-column') ] :\n\t\t\t[];\n\t};\n\n\treturn _selector_run( 'column', selector, run, settings, opts );\n};\n\n\nvar __setColumnVis = function ( settings, column, vis ) {\n\tvar\n\t\tcols = settings.aoColumns,\n\t\tcol  = cols[ column ],\n\t\tdata = settings.aoData,\n\t\trow, cells, i, ien, tr;\n\n\t// Get\n\tif ( vis === undefined ) {\n\t\treturn col.bVisible;\n\t}\n\n\t// Set\n\t// No change\n\tif ( col.bVisible === vis ) {\n\t\treturn;\n\t}\n\n\tif ( vis ) {\n\t\t// Insert column\n\t\t// Need to decide if we should use appendChild or insertBefore\n\t\tvar insertBefore = $.inArray( true, _pluck(cols, 'bVisible'), column+1 );\n\n\t\tfor ( i=0, ien=data.length ; i<ien ; i++ ) {\n\t\t\ttr = data[i].nTr;\n\t\t\tcells = data[i].anCells;\n\n\t\t\tif ( tr ) {\n\t\t\t\t// insertBefore can act like appendChild if 2nd arg is null\n\t\t\t\ttr.insertBefore( cells[ column ], cells[ insertBefore ] || null );\n\t\t\t}\n\t\t}\n\t}\n\telse {\n\t\t// Remove column\n\t\t$( _pluck( settings.aoData, 'anCells', column ) ).detach();\n\t}\n\n\t// Common actions\n\tcol.bVisible = vis;\n};\n\n\n_api_register( 'columns()', function ( selector, opts ) {\n\t// argument shifting\n\tif ( selector === undefined ) {\n\t\tselector = '';\n\t}\n\telse if ( $.isPlainObject( selector ) ) {\n\t\topts = selector;\n\t\tselector = '';\n\t}\n\n\topts = _selector_opts( opts );\n\n\tvar inst = this.iterator( 'table', function ( settings ) {\n\t\treturn __column_selector( settings, selector, opts );\n\t}, 1 );\n\n\t// Want argument shifting here and in _row_selector?\n\tinst.selector.cols = selector;\n\tinst.selector.opts = opts;\n\n\treturn inst;\n} );\n\n_api_registerPlural( 'columns().header()', 'column().header()', function ( selector, opts ) {\n\treturn this.iterator( 'column', function ( settings, column ) {\n\t\treturn settings.aoColumns[column].nTh;\n\t}, 1 );\n} );\n\n_api_registerPlural( 'columns().footer()', 'column().footer()', function ( selector, opts ) {\n\treturn this.iterator( 'column', function ( settings, column ) {\n\t\treturn settings.aoColumns[column].nTf;\n\t}, 1 );\n} );\n\n_api_registerPlural( 'columns().data()', 'column().data()', function () {\n\treturn this.iterator( 'column-rows', __columnData, 1 );\n} );\n\n_api_registerPlural( 'columns().dataSrc()', 'column().dataSrc()', function () {\n\treturn this.iterator( 'column', function ( settings, column ) {\n\t\treturn settings.aoColumns[column].mData;\n\t}, 1 );\n} );\n\n_api_registerPlural( 'columns().cache()', 'column().cache()', function ( type ) {\n\treturn this.iterator( 'column-rows', function ( settings, column, i, j, rows ) {\n\t\treturn _pluck_order( settings.aoData, rows,\n\t\t\ttype === 'search' ? '_aFilterData' : '_aSortData', column\n\t\t);\n\t}, 1 );\n} );\n\n_api_registerPlural( 'columns().nodes()', 'column().nodes()', function () {\n\treturn this.iterator( 'column-rows', function ( settings, column, i, j, rows ) {\n\t\treturn _pluck_order( settings.aoData, rows, 'anCells', column ) ;\n\t}, 1 );\n} );\n\n_api_registerPlural( 'columns().visible()', 'column().visible()', function ( vis, calc ) {\n\tvar that = this;\n\tvar ret = this.iterator( 'column', function ( settings, column ) {\n\t\tif ( vis === undefined ) {\n\t\t\treturn settings.aoColumns[ column ].bVisible;\n\t\t} // else\n\t\t__setColumnVis( settings, column, vis );\n\t} );\n\n\t// Group the column visibility changes\n\tif ( vis !== undefined ) {\n\t\tthis.iterator( 'table', function ( settings ) {\n\t\t\t// Redraw the header after changes\n\t\t\t_fnDrawHead( settings, settings.aoHeader );\n\t\t\t_fnDrawHead( settings, settings.aoFooter );\n\t\n\t\t\t// Update colspan for no records display. Child rows and extensions will use their own\n\t\t\t// listeners to do this - only need to update the empty table item here\n\t\t\tif ( ! settings.aiDisplay.length ) {\n\t\t\t\t$(settings.nTBody).find('td[colspan]').attr('colspan', _fnVisbleColumns(settings));\n\t\t\t}\n\t\n\t\t\t_fnSaveState( settings );\n\n\t\t\t// Second loop once the first is done for events\n\t\t\tthat.iterator( 'column', function ( settings, column ) {\n\t\t\t\t_fnCallbackFire( settings, null, 'column-visibility', [settings, column, vis, calc] );\n\t\t\t} );\n\n\t\t\tif ( calc === undefined || calc ) {\n\t\t\t\tthat.columns.adjust();\n\t\t\t}\n\t\t});\n\t}\n\n\treturn ret;\n} );\n\n_api_registerPlural( 'columns().indexes()', 'column().index()', function ( type ) {\n\treturn this.iterator( 'column', function ( settings, column ) {\n\t\treturn type === 'visible' ?\n\t\t\t_fnColumnIndexToVisible( settings, column ) :\n\t\t\tcolumn;\n\t}, 1 );\n} );\n\n_api_register( 'columns.adjust()', function () {\n\treturn this.iterator( 'table', function ( settings ) {\n\t\t_fnAdjustColumnSizing( settings );\n\t}, 1 );\n} );\n\n_api_register( 'column.index()', function ( type, idx ) {\n\tif ( this.context.length !== 0 ) {\n\t\tvar ctx = this.context[0];\n\n\t\tif ( type === 'fromVisible' || type === 'toData' ) {\n\t\t\treturn _fnVisibleToColumnIndex( ctx, idx );\n\t\t}\n\t\telse if ( type === 'fromData' || type === 'toVisible' ) {\n\t\t\treturn _fnColumnIndexToVisible( ctx, idx );\n\t\t}\n\t}\n} );\n\n_api_register( 'column()', function ( selector, opts ) {\n\treturn _selector_first( this.columns( selector, opts ) );\n} );\n\nvar __cell_selector = function ( settings, selector, opts )\n{\n\tvar data = settings.aoData;\n\tvar rows = _selector_row_indexes( settings, opts );\n\tvar cells = _removeEmpty( _pluck_order( data, rows, 'anCells' ) );\n\tvar allCells = $(_flatten( [], cells ));\n\tvar row;\n\tvar columns = settings.aoColumns.length;\n\tvar a, i, ien, j, o, host;\n\n\tvar run = function ( s ) {\n\t\tvar fnSelector = typeof s === 'function';\n\n\t\tif ( s === null || s === undefined || fnSelector ) {\n\t\t\t// All cells and function selectors\n\t\t\ta = [];\n\n\t\t\tfor ( i=0, ien=rows.length ; i<ien ; i++ ) {\n\t\t\t\trow = rows[i];\n\n\t\t\t\tfor ( j=0 ; j<columns ; j++ ) {\n\t\t\t\t\to = {\n\t\t\t\t\t\trow: row,\n\t\t\t\t\t\tcolumn: j\n\t\t\t\t\t};\n\n\t\t\t\t\tif ( fnSelector ) {\n\t\t\t\t\t\t// Selector - function\n\t\t\t\t\t\thost = data[ row ];\n\n\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\ta.push( o );\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// Selector - all\n\t\t\t\t\t\ta.push( o );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn a;\n\t\t}\n\t\t\n\t\t// Selector - index\n\t\tif ( $.isPlainObject( s ) ) {\n\t\t\t// Valid cell index and its in the array of selectable rows\n\t\t\treturn s.column !== undefined && s.row !== undefined && $.inArray( s.row, rows ) !== -1 ?\n\t\t\t\t[s] :\n\t\t\t\t[];\n\t\t}\n\n\t\t// Selector - jQuery filtered cells\n\t\tvar jqResult = allCells\n\t\t\t.filter( s )\n\t\t\t.map( function (i, el) {\n\t\t\t\treturn { // use a new object, in case someone changes the values\n\t\t\t\t\trow:    el._DT_CellIndex.row,\n\t\t\t\t\tcolumn: el._DT_CellIndex.column\n \t\t\t\t};\n\t\t\t} )\n\t\t\t.toArray();\n\n\t\tif ( jqResult.length || ! s.nodeName ) {\n\t\t\treturn jqResult;\n\t\t}\n\n\t\t// Otherwise the selector is a node, and there is one last option - the\n\t\t// element might be a child of an element which has dt-row and dt-column\n\t\t// data attributes\n\t\thost = $(s).closest('*[data-dt-row]');\n\t\treturn host.length ?\n\t\t\t[ {\n\t\t\t\trow: host.data('dt-row'),\n\t\t\t\tcolumn: host.data('dt-column')\n\t\t\t} ] :\n\t\t\t[];\n\t};\n\n\treturn _selector_run( 'cell', selector, run, settings, opts );\n};\n\n\n\n\n_api_register( 'cells()', function ( rowSelector, columnSelector, opts ) {\n\t// Argument shifting\n\tif ( $.isPlainObject( rowSelector ) ) {\n\t\t// Indexes\n\t\tif ( rowSelector.row === undefined ) {\n\t\t\t// Selector options in first parameter\n\t\t\topts = rowSelector;\n\t\t\trowSelector = null;\n\t\t}\n\t\telse {\n\t\t\t// Cell index objects in first parameter\n\t\t\topts = columnSelector;\n\t\t\tcolumnSelector = null;\n\t\t}\n\t}\n\tif ( $.isPlainObject( columnSelector ) ) {\n\t\topts = columnSelector;\n\t\tcolumnSelector = null;\n\t}\n\n\t// Cell selector\n\tif ( columnSelector === null || columnSelector === undefined ) {\n\t\treturn this.iterator( 'table', function ( settings ) {\n\t\t\treturn __cell_selector( settings, rowSelector, _selector_opts( opts ) );\n\t\t} );\n\t}\n\n\t// The default built in options need to apply to row and columns\n\tvar internalOpts = opts ? {\n\t\tpage: opts.page,\n\t\torder: opts.order,\n\t\tsearch: opts.search\n\t} : {};\n\n\t// Row + column selector\n\tvar columns = this.columns( columnSelector, internalOpts );\n\tvar rows = this.rows( rowSelector, internalOpts );\n\tvar i, ien, j, jen;\n\n\tvar cellsNoOpts = this.iterator( 'table', function ( settings, idx ) {\n\t\tvar a = [];\n\n\t\tfor ( i=0, ien=rows[idx].length ; i<ien ; i++ ) {\n\t\t\tfor ( j=0, jen=columns[idx].length ; j<jen ; j++ ) {\n\t\t\t\ta.push( {\n\t\t\t\t\trow:    rows[idx][i],\n\t\t\t\t\tcolumn: columns[idx][j]\n\t\t\t\t} );\n\t\t\t}\n\t\t}\n\n\t\treturn a;\n\t}, 1 );\n\n\t// There is currently only one extension which uses a cell selector extension\n\t// It is a _major_ performance drag to run this if it isn't needed, so this is\n\t// an extension specific check at the moment\n\tvar cells = opts && opts.selected ?\n\t\tthis.cells( cellsNoOpts, opts ) :\n\t\tcellsNoOpts;\n\n\t$.extend( cells.selector, {\n\t\tcols: columnSelector,\n\t\trows: rowSelector,\n\t\topts: opts\n\t} );\n\n\treturn cells;\n} );\n\n\n_api_registerPlural( 'cells().nodes()', 'cell().node()', function () {\n\treturn this.iterator( 'cell', function ( settings, row, column ) {\n\t\tvar data = settings.aoData[ row ];\n\n\t\treturn data && data.anCells ?\n\t\t\tdata.anCells[ column ] :\n\t\t\tundefined;\n\t}, 1 );\n} );\n\n\n_api_register( 'cells().data()', function () {\n\treturn this.iterator( 'cell', function ( settings, row, column ) {\n\t\treturn _fnGetCellData( settings, row, column );\n\t}, 1 );\n} );\n\n\n_api_registerPlural( 'cells().cache()', 'cell().cache()', function ( type ) {\n\ttype = type === 'search' ? '_aFilterData' : '_aSortData';\n\n\treturn this.iterator( 'cell', function ( settings, row, column ) {\n\t\treturn settings.aoData[ row ][ type ][ column ];\n\t}, 1 );\n} );\n\n\n_api_registerPlural( 'cells().render()', 'cell().render()', function ( type ) {\n\treturn this.iterator( 'cell', function ( settings, row, column ) {\n\t\treturn _fnGetCellData( settings, row, column, type );\n\t}, 1 );\n} );\n\n\n_api_registerPlural( 'cells().indexes()', 'cell().index()', function () {\n\treturn this.iterator( 'cell', function ( settings, row, column ) {\n\t\treturn {\n\t\t\trow: row,\n\t\t\tcolumn: column,\n\t\t\tcolumnVisible: _fnColumnIndexToVisible( settings, column )\n\t\t};\n\t}, 1 );\n} );\n\n\n_api_registerPlural( 'cells().invalidate()', 'cell().invalidate()', function ( src ) {\n\treturn this.iterator( 'cell', function ( settings, row, column ) {\n\t\t_fnInvalidate( settings, row, src, column );\n\t} );\n} );\n\n\n\n_api_register( 'cell()', function ( rowSelector, columnSelector, opts ) {\n\treturn _selector_first( this.cells( rowSelector, columnSelector, opts ) );\n} );\n\n\n_api_register( 'cell().data()', function ( data ) {\n\tvar ctx = this.context;\n\tvar cell = this[0];\n\n\tif ( data === undefined ) {\n\t\t// Get\n\t\treturn ctx.length && cell.length ?\n\t\t\t_fnGetCellData( ctx[0], cell[0].row, cell[0].column ) :\n\t\t\tundefined;\n\t}\n\n\t// Set\n\t_fnSetCellData( ctx[0], cell[0].row, cell[0].column, data );\n\t_fnInvalidate( ctx[0], cell[0].row, 'data', cell[0].column );\n\n\treturn this;\n} );\n\n\n\n/**\n * Get current ordering (sorting) that has been applied to the table.\n *\n * @returns {array} 2D array containing the sorting information for the first\n *   table in the current context. Each element in the parent array represents\n *   a column being sorted upon (i.e. multi-sorting with two columns would have\n *   2 inner arrays). The inner arrays may have 2 or 3 elements. The first is\n *   the column index that the sorting condition applies to, the second is the\n *   direction of the sort (`desc` or `asc`) and, optionally, the third is the\n *   index of the sorting order from the `column.sorting` initialisation array.\n *//**\n * Set the ordering for the table.\n *\n * @param {integer} order Column index to sort upon.\n * @param {string} direction Direction of the sort to be applied (`asc` or `desc`)\n * @returns {DataTables.Api} this\n *//**\n * Set the ordering for the table.\n *\n * @param {array} order 1D array of sorting information to be applied.\n * @param {array} [...] Optional additional sorting conditions\n * @returns {DataTables.Api} this\n *//**\n * Set the ordering for the table.\n *\n * @param {array} order 2D array of sorting information to be applied.\n * @returns {DataTables.Api} this\n */\n_api_register( 'order()', function ( order, dir ) {\n\tvar ctx = this.context;\n\n\tif ( order === undefined ) {\n\t\t// get\n\t\treturn ctx.length !== 0 ?\n\t\t\tctx[0].aaSorting :\n\t\t\tundefined;\n\t}\n\n\t// set\n\tif ( typeof order === 'number' ) {\n\t\t// Simple column / direction passed in\n\t\torder = [ [ order, dir ] ];\n\t}\n\telse if ( order.length && ! Array.isArray( order[0] ) ) {\n\t\t// Arguments passed in (list of 1D arrays)\n\t\torder = Array.prototype.slice.call( arguments );\n\t}\n\t// otherwise a 2D array was passed in\n\n\treturn this.iterator( 'table', function ( settings ) {\n\t\tsettings.aaSorting = order.slice();\n\t} );\n} );\n\n\n/**\n * Attach a sort listener to an element for a given column\n *\n * @param {node|jQuery|string} node Identifier for the element(s) to attach the\n *   listener to. This can take the form of a single DOM node, a jQuery\n *   collection of nodes or a jQuery selector which will identify the node(s).\n * @param {integer} column the column that a click on this node will sort on\n * @param {function} [callback] callback function when sort is run\n * @returns {DataTables.Api} this\n */\n_api_register( 'order.listener()', function ( node, column, callback ) {\n\treturn this.iterator( 'table', function ( settings ) {\n\t\t_fnSortAttachListener( settings, node, column, callback );\n\t} );\n} );\n\n\n_api_register( 'order.fixed()', function ( set ) {\n\tif ( ! set ) {\n\t\tvar ctx = this.context;\n\t\tvar fixed = ctx.length ?\n\t\t\tctx[0].aaSortingFixed :\n\t\t\tundefined;\n\n\t\treturn Array.isArray( fixed ) ?\n\t\t\t{ pre: fixed } :\n\t\t\tfixed;\n\t}\n\n\treturn this.iterator( 'table', function ( settings ) {\n\t\tsettings.aaSortingFixed = $.extend( true, {}, set );\n\t} );\n} );\n\n\n// Order by the selected column(s)\n_api_register( [\n\t'columns().order()',\n\t'column().order()'\n], function ( dir ) {\n\tvar that = this;\n\n\treturn this.iterator( 'table', function ( settings, i ) {\n\t\tvar sort = [];\n\n\t\t$.each( that[i], function (j, col) {\n\t\t\tsort.push( [ col, dir ] );\n\t\t} );\n\n\t\tsettings.aaSorting = sort;\n\t} );\n} );\n\n\n\n_api_register( 'search()', function ( input, regex, smart, caseInsen ) {\n\tvar ctx = this.context;\n\n\tif ( input === undefined ) {\n\t\t// get\n\t\treturn ctx.length !== 0 ?\n\t\t\tctx[0].oPreviousSearch.sSearch :\n\t\t\tundefined;\n\t}\n\n\t// set\n\treturn this.iterator( 'table', function ( settings ) {\n\t\tif ( ! settings.oFeatures.bFilter ) {\n\t\t\treturn;\n\t\t}\n\n\t\t_fnFilterComplete( settings, $.extend( {}, settings.oPreviousSearch, {\n\t\t\t\"sSearch\": input+\"\",\n\t\t\t\"bRegex\":  regex === null ? false : regex,\n\t\t\t\"bSmart\":  smart === null ? true  : smart,\n\t\t\t\"bCaseInsensitive\": caseInsen === null ? true : caseInsen\n\t\t} ), 1 );\n\t} );\n} );\n\n\n_api_registerPlural(\n\t'columns().search()',\n\t'column().search()',\n\tfunction ( input, regex, smart, caseInsen ) {\n\t\treturn this.iterator( 'column', function ( settings, column ) {\n\t\t\tvar preSearch = settings.aoPreSearchCols;\n\n\t\t\tif ( input === undefined ) {\n\t\t\t\t// get\n\t\t\t\treturn preSearch[ column ].sSearch;\n\t\t\t}\n\n\t\t\t// set\n\t\t\tif ( ! settings.oFeatures.bFilter ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t$.extend( preSearch[ column ], {\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} );\n\n\t\t\t_fnFilterComplete( settings, settings.oPreviousSearch, 1 );\n\t\t} );\n\t}\n);\n\n/*\n * State API methods\n */\n\n_api_register( 'state()', function () {\n\treturn this.context.length ?\n\t\tthis.context[0].oSavedState :\n\t\tnull;\n} );\n\n\n_api_register( 'state.clear()', function () {\n\treturn this.iterator( 'table', function ( settings ) {\n\t\t// Save an empty object\n\t\tsettings.fnStateSaveCallback.call( settings.oInstance, settings, {} );\n\t} );\n} );\n\n\n_api_register( 'state.loaded()', function () {\n\treturn this.context.length ?\n\t\tthis.context[0].oLoadedState :\n\t\tnull;\n} );\n\n\n_api_register( 'state.save()', function () {\n\treturn this.iterator( 'table', function ( settings ) {\n\t\t_fnSaveState( settings );\n\t} );\n} );\n\n\n\n/**\n * Set the jQuery or window object to be used by DataTables\n *\n * @param {*} module Library / container object\n * @param {string} [type] Library or container type `lib`, `win` or `datetime`.\n *   If not provided, automatic detection is attempted.\n */\nDataTable.use = function (module, type) {\n\tif (type === 'lib' || module.fn) {\n\t\t$ = module;\n\t}\n\telse if (type == 'win' || module.document) {\n\t\twindow = module;\n\t\tdocument = module.document;\n\t}\n\telse if (type === 'datetime' || module.type === 'DateTime') {\n\t\tDataTable.DateTime = module;\n\t}\n}\n\n/**\n * CommonJS factory function pass through. This will check if the arguments\n * given are a window object or a jQuery object. If so they are set\n * accordingly.\n * @param {*} root Window\n * @param {*} jq jQUery\n * @returns {boolean} Indicator\n */\nDataTable.factory = function (root, jq) {\n\tvar is = false;\n\n\t// Test if the first parameter is a window object\n\tif (root && root.document) {\n\t\twindow = root;\n\t\tdocument = root.document;\n\t}\n\n\t// Test if the second parameter is a jQuery object\n\tif (jq && jq.fn && jq.fn.jquery) {\n\t\t$ = jq;\n\t\tis = true;\n\t}\n\n\treturn is;\n}\n\n/**\n * Provide a common method for plug-ins to check the version of DataTables being\n * used, in order to ensure compatibility.\n *\n *  @param {string} version Version string to check for, in the format \"X.Y.Z\".\n *    Note that the formats \"X\" and \"X.Y\" are also acceptable.\n *  @returns {boolean} true if this version of DataTables is greater or equal to\n *    the required version, or false if this version of DataTales is not\n *    suitable\n *  @static\n *  @dtopt API-Static\n *\n *  @example\n *    alert( $.fn.dataTable.versionCheck( '1.9.0' ) );\n */\nDataTable.versionCheck = DataTable.fnVersionCheck = function( version )\n{\n\tvar aThis = DataTable.version.split('.');\n\tvar aThat = version.split('.');\n\tvar iThis, iThat;\n\n\tfor ( var i=0, iLen=aThat.length ; i<iLen ; i++ ) {\n\t\tiThis = parseInt( aThis[i], 10 ) || 0;\n\t\tiThat = parseInt( aThat[i], 10 ) || 0;\n\n\t\t// Parts are the same, keep comparing\n\t\tif (iThis === iThat) {\n\t\t\tcontinue;\n\t\t}\n\n\t\t// Parts are different, return immediately\n\t\treturn iThis > iThat;\n\t}\n\n\treturn true;\n};\n\n\n/**\n * Check if a `<table>` node is a DataTable table already or not.\n *\n *  @param {node|jquery|string} table Table node, jQuery object or jQuery\n *      selector for the table to test. Note that if more than more than one\n *      table is passed on, only the first will be checked\n *  @returns {boolean} true the table given is a DataTable, or false otherwise\n *  @static\n *  @dtopt API-Static\n *\n *  @example\n *    if ( ! $.fn.DataTable.isDataTable( '#example' ) ) {\n *      $('#example').dataTable();\n *    }\n */\nDataTable.isDataTable = DataTable.fnIsDataTable = function ( table )\n{\n\tvar t = $(table).get(0);\n\tvar is = false;\n\n\tif ( table instanceof DataTable.Api ) {\n\t\treturn true;\n\t}\n\n\t$.each( DataTable.settings, function (i, o) {\n\t\tvar head = o.nScrollHead ? $('table', o.nScrollHead)[0] : null;\n\t\tvar foot = o.nScrollFoot ? $('table', o.nScrollFoot)[0] : null;\n\n\t\tif ( o.nTable === t || head === t || foot === t ) {\n\t\t\tis = true;\n\t\t}\n\t} );\n\n\treturn is;\n};\n\n\n/**\n * Get all DataTable tables that have been initialised - optionally you can\n * select to get only currently visible tables.\n *\n *  @param {boolean} [visible=false] Flag to indicate if you want all (default)\n *    or visible tables only.\n *  @returns {array} Array of `table` nodes (not DataTable instances) which are\n *    DataTables\n *  @static\n *  @dtopt API-Static\n *\n *  @example\n *    $.each( $.fn.dataTable.tables(true), function () {\n *      $(table).DataTable().columns.adjust();\n *    } );\n */\nDataTable.tables = DataTable.fnTables = function ( visible )\n{\n\tvar api = false;\n\n\tif ( $.isPlainObject( visible ) ) {\n\t\tapi = visible.api;\n\t\tvisible = visible.visible;\n\t}\n\n\tvar a = $.map( DataTable.settings, function (o) {\n\t\tif ( !visible || (visible && $(o.nTable).is(':visible')) ) {\n\t\t\treturn o.nTable;\n\t\t}\n\t} );\n\n\treturn api ?\n\t\tnew _Api( a ) :\n\t\ta;\n};\n\n\n/**\n * Convert from camel case parameters to Hungarian notation. This is made public\n * for the extensions to provide the same ability as DataTables core to accept\n * either the 1.9 style Hungarian notation, or the 1.10+ style camelCase\n * parameters.\n *\n *  @param {object} src The model object which holds all parameters that can be\n *    mapped.\n *  @param {object} user The object to convert from camel case to Hungarian.\n *  @param {boolean} force When set to `true`, properties which already have a\n *    Hungarian value in the `user` object will be overwritten. Otherwise they\n *    won't be.\n */\nDataTable.camelToHungarian = _fnCamelToHungarian;\n\n\n\n/**\n *\n */\n_api_register( '$()', function ( selector, opts ) {\n\tvar\n\t\trows   = this.rows( opts ).nodes(), // Get all rows\n\t\tjqRows = $(rows);\n\n\treturn $( [].concat(\n\t\tjqRows.filter( selector ).toArray(),\n\t\tjqRows.find( selector ).toArray()\n\t) );\n} );\n\n\n// jQuery functions to operate on the tables\n$.each( [ 'on', 'one', 'off' ], function (i, key) {\n\t_api_register( key+'()', function ( /* event, handler */ ) {\n\t\tvar args = Array.prototype.slice.call(arguments);\n\n\t\t// Add the `dt` namespace automatically if it isn't already present\n\t\targs[0] = $.map( args[0].split( /\\s/ ), function ( e ) {\n\t\t\treturn ! e.match(/\\.dt\\b/) ?\n\t\t\t\te+'.dt' :\n\t\t\t\te;\n\t\t\t} ).join( ' ' );\n\n\t\tvar inst = $( this.tables().nodes() );\n\t\tinst[key].apply( inst, args );\n\t\treturn this;\n\t} );\n} );\n\n\n_api_register( 'clear()', function () {\n\treturn this.iterator( 'table', function ( settings ) {\n\t\t_fnClearTable( settings );\n\t} );\n} );\n\n\n_api_register( 'settings()', function () {\n\treturn new _Api( this.context, this.context );\n} );\n\n\n_api_register( 'init()', function () {\n\tvar ctx = this.context;\n\treturn ctx.length ? ctx[0].oInit : null;\n} );\n\n\n_api_register( 'data()', function () {\n\treturn this.iterator( 'table', function ( settings ) {\n\t\treturn _pluck( settings.aoData, '_aData' );\n\t} ).flatten();\n} );\n\n\n_api_register( 'destroy()', function ( remove ) {\n\tremove = remove || false;\n\n\treturn this.iterator( 'table', function ( settings ) {\n\t\tvar classes   = settings.oClasses;\n\t\tvar table     = settings.nTable;\n\t\tvar tbody     = settings.nTBody;\n\t\tvar thead     = settings.nTHead;\n\t\tvar tfoot     = settings.nTFoot;\n\t\tvar jqTable   = $(table);\n\t\tvar jqTbody   = $(tbody);\n\t\tvar jqWrapper = $(settings.nTableWrapper);\n\t\tvar rows      = $.map( settings.aoData, function (r) { return r.nTr; } );\n\t\tvar i, ien;\n\n\t\t// Flag to note that the table is currently being destroyed - no action\n\t\t// should be taken\n\t\tsettings.bDestroying = true;\n\n\t\t// Fire off the destroy callbacks for plug-ins etc\n\t\t_fnCallbackFire( settings, \"aoDestroyCallback\", \"destroy\", [settings] );\n\n\t\t// If not being removed from the document, make all columns visible\n\t\tif ( ! remove ) {\n\t\t\tnew _Api( settings ).columns().visible( true );\n\t\t}\n\n\t\t// Blitz all `DT` namespaced events (these are internal events, the\n\t\t// lowercase, `dt` events are user subscribed and they are responsible\n\t\t// for removing them\n\t\tjqWrapper.off('.DT').find(':not(tbody *)').off('.DT');\n\t\t$(window).off('.DT-'+settings.sInstance);\n\n\t\t// When scrolling we had to break the table up - restore it\n\t\tif ( table != thead.parentNode ) {\n\t\t\tjqTable.children('thead').detach();\n\t\t\tjqTable.append( thead );\n\t\t}\n\n\t\tif ( tfoot && table != tfoot.parentNode ) {\n\t\t\tjqTable.children('tfoot').detach();\n\t\t\tjqTable.append( tfoot );\n\t\t}\n\n\t\tsettings.aaSorting = [];\n\t\tsettings.aaSortingFixed = [];\n\t\t_fnSortingClasses( settings );\n\n\t\t$( rows ).removeClass( settings.asStripeClasses.join(' ') );\n\n\t\t$('th, td', thead).removeClass( classes.sSortable+' '+\n\t\t\tclasses.sSortableAsc+' '+classes.sSortableDesc+' '+classes.sSortableNone\n\t\t);\n\n\t\t// Add the TR elements back into the table in their original order\n\t\tjqTbody.children().detach();\n\t\tjqTbody.append( rows );\n\n\t\tvar orig = settings.nTableWrapper.parentNode;\n\n\t\t// Remove the DataTables generated nodes, events and classes\n\t\tvar removedMethod = remove ? 'remove' : 'detach';\n\t\tjqTable[ removedMethod ]();\n\t\tjqWrapper[ removedMethod ]();\n\n\t\t// If we need to reattach the table to the document\n\t\tif ( ! remove && orig ) {\n\t\t\t// insertBefore acts like appendChild if !arg[1]\n\t\t\torig.insertBefore( table, settings.nTableReinsertBefore );\n\n\t\t\t// Restore the width of the original table - was read from the style property,\n\t\t\t// so we can restore directly to that\n\t\t\tjqTable\n\t\t\t\t.css( 'width', settings.sDestroyWidth )\n\t\t\t\t.removeClass( classes.sTable );\n\n\t\t\t// If the were originally stripe classes - then we add them back here.\n\t\t\t// Note this is not fool proof (for example if not all rows had stripe\n\t\t\t// classes - but it's a good effort without getting carried away\n\t\t\tien = settings.asDestroyStripes.length;\n\n\t\t\tif ( ien ) {\n\t\t\t\tjqTbody.children().each( function (i) {\n\t\t\t\t\t$(this).addClass( settings.asDestroyStripes[i % ien] );\n\t\t\t\t} );\n\t\t\t}\n\t\t}\n\n\t\t/* Remove the settings object from the settings array */\n\t\tvar idx = $.inArray( settings, DataTable.settings );\n\t\tif ( idx !== -1 ) {\n\t\t\tDataTable.settings.splice( idx, 1 );\n\t\t}\n\t} );\n} );\n\n\n// Add the `every()` method for rows, columns and cells in a compact form\n$.each( [ 'column', 'row', 'cell' ], function ( i, type ) {\n\t_api_register( type+'s().every()', function ( fn ) {\n\t\tvar opts = this.selector.opts;\n\t\tvar api = this;\n\n\t\treturn this.iterator( type, function ( settings, arg1, arg2, arg3, arg4 ) {\n\t\t\t// Rows and columns:\n\t\t\t//  arg1 - index\n\t\t\t//  arg2 - table counter\n\t\t\t//  arg3 - loop counter\n\t\t\t//  arg4 - undefined\n\t\t\t// Cells:\n\t\t\t//  arg1 - row index\n\t\t\t//  arg2 - column index\n\t\t\t//  arg3 - table counter\n\t\t\t//  arg4 - loop counter\n\t\t\tfn.call(\n\t\t\t\tapi[ type ](\n\t\t\t\t\targ1,\n\t\t\t\t\ttype==='cell' ? arg2 : opts,\n\t\t\t\t\ttype==='cell' ? opts : undefined\n\t\t\t\t),\n\t\t\t\targ1, arg2, arg3, arg4\n\t\t\t);\n\t\t} );\n\t} );\n} );\n\n\n// i18n method for extensions to be able to use the language object from the\n// DataTable\n_api_register( 'i18n()', function ( token, def, plural ) {\n\tvar ctx = this.context[0];\n\tvar resolved = _fnGetObjectDataFn( token )( ctx.oLanguage );\n\n\tif ( resolved === undefined ) {\n\t\tresolved = def;\n\t}\n\n\tif ( plural !== undefined && $.isPlainObject( resolved ) ) {\n\t\tresolved = resolved[ plural ] !== undefined ?\n\t\t\tresolved[ plural ] :\n\t\t\tresolved._;\n\t}\n\n\treturn typeof resolved === 'string'\n\t\t? resolved.replace( '%d', plural ) // nb: plural might be undefined,\n\t\t: resolved;\n} );\n/**\n * Version string for plug-ins to check compatibility. Allowed format is\n * `a.b.c-d` where: a:int, b:int, c:int, d:string(dev|beta|alpha). `d` is used\n * only for non-release builds. See https://semver.org/ for more information.\n *  @member\n *  @type string\n *  @default Version number\n */\nDataTable.version = \"1.13.7\";\n\n/**\n * Private data store, containing all of the settings objects that are\n * created for the tables on a given page.\n *\n * Note that the `DataTable.settings` object is aliased to\n * `jQuery.fn.dataTableExt` through which it may be accessed and\n * manipulated, or `jQuery.fn.dataTable.settings`.\n *  @member\n *  @type array\n *  @default []\n *  @private\n */\nDataTable.settings = [];\n\n/**\n * Object models container, for the various models that DataTables has\n * available to it. These models define the objects that are used to hold\n * the active state and configuration of the table.\n *  @namespace\n */\nDataTable.models = {};\n\n\n\n/**\n * Template object for the way in which DataTables holds information about\n * search information for the global filter and individual column filters.\n *  @namespace\n */\nDataTable.models.oSearch = {\n\t/**\n\t * Flag to indicate if the filtering should be case insensitive or not\n\t *  @type boolean\n\t *  @default true\n\t */\n\t\"bCaseInsensitive\": true,\n\n\t/**\n\t * Applied search term\n\t *  @type string\n\t *  @default <i>Empty string</i>\n\t */\n\t\"sSearch\": \"\",\n\n\t/**\n\t * Flag to indicate if the search term should be interpreted as a\n\t * regular expression (true) or not (false) and therefore and special\n\t * regex characters escaped.\n\t *  @type boolean\n\t *  @default false\n\t */\n\t\"bRegex\": false,\n\n\t/**\n\t * Flag to indicate if DataTables is to use its smart filtering or not.\n\t *  @type boolean\n\t *  @default true\n\t */\n\t\"bSmart\": true,\n\n\t/**\n\t * Flag to indicate if DataTables should only trigger a search when\n\t * the return key is pressed.\n\t *  @type boolean\n\t *  @default false\n\t */\n\t\"return\": false\n};\n\n\n\n\n/**\n * Template object for the way in which DataTables holds information about\n * each individual row. This is the object format used for the settings\n * aoData array.\n *  @namespace\n */\nDataTable.models.oRow = {\n\t/**\n\t * TR element for the row\n\t *  @type node\n\t *  @default null\n\t */\n\t\"nTr\": null,\n\n\t/**\n\t * Array of TD elements for each row. This is null until the row has been\n\t * created.\n\t *  @type array nodes\n\t *  @default []\n\t */\n\t\"anCells\": null,\n\n\t/**\n\t * Data object from the original data source for the row. This is either\n\t * an array if using the traditional form of DataTables, or an object if\n\t * using mData options. The exact type will depend on the passed in\n\t * data from the data source, or will be an array if using DOM a data\n\t * source.\n\t *  @type array|object\n\t *  @default []\n\t */\n\t\"_aData\": [],\n\n\t/**\n\t * Sorting data cache - this array is ostensibly the same length as the\n\t * number of columns (although each index is generated only as it is\n\t * needed), and holds the data that is used for sorting each column in the\n\t * row. We do this cache generation at the start of the sort in order that\n\t * the formatting of the sort data need be done only once for each cell\n\t * per sort. This array should not be read from or written to by anything\n\t * other than the master sorting methods.\n\t *  @type array\n\t *  @default null\n\t *  @private\n\t */\n\t\"_aSortData\": null,\n\n\t/**\n\t * Per cell filtering data cache. As per the sort data cache, used to\n\t * increase the performance of the filtering in DataTables\n\t *  @type array\n\t *  @default null\n\t *  @private\n\t */\n\t\"_aFilterData\": null,\n\n\t/**\n\t * Filtering data cache. This is the same as the cell filtering cache, but\n\t * in this case a string rather than an array. This is easily computed with\n\t * a join on `_aFilterData`, but is provided as a cache so the join isn't\n\t * needed on every search (memory traded for performance)\n\t *  @type array\n\t *  @default null\n\t *  @private\n\t */\n\t\"_sFilterRow\": null,\n\n\t/**\n\t * Cache of the class name that DataTables has applied to the row, so we\n\t * can quickly look at this variable rather than needing to do a DOM check\n\t * on className for the nTr property.\n\t *  @type string\n\t *  @default <i>Empty string</i>\n\t *  @private\n\t */\n\t\"_sRowStripe\": \"\",\n\n\t/**\n\t * Denote if the original data source was from the DOM, or the data source\n\t * object. This is used for invalidating data, so DataTables can\n\t * automatically read data from the original source, unless uninstructed\n\t * otherwise.\n\t *  @type string\n\t *  @default null\n\t *  @private\n\t */\n\t\"src\": null,\n\n\t/**\n\t * Index in the aoData array. This saves an indexOf lookup when we have the\n\t * object, but want to know the index\n\t *  @type integer\n\t *  @default -1\n\t *  @private\n\t */\n\t\"idx\": -1\n};\n\n\n/**\n * Template object for the column information object in DataTables. This object\n * is held in the settings aoColumns array and contains all the information that\n * DataTables needs about each individual column.\n *\n * Note that this object is related to {@link DataTable.defaults.column}\n * but this one is the internal data store for DataTables's cache of columns.\n * It should NOT be manipulated outside of DataTables. Any configuration should\n * be done through the initialisation options.\n *  @namespace\n */\nDataTable.models.oColumn = {\n\t/**\n\t * Column index. This could be worked out on-the-fly with $.inArray, but it\n\t * is faster to just hold it as a variable\n\t *  @type integer\n\t *  @default null\n\t */\n\t\"idx\": null,\n\n\t/**\n\t * A list of the columns that sorting should occur on when this column\n\t * is sorted. That this property is an array allows multi-column sorting\n\t * to be defined for a column (for example first name / last name columns\n\t * would benefit from this). The values are integers pointing to the\n\t * columns to be sorted on (typically it will be a single integer pointing\n\t * at itself, but that doesn't need to be the case).\n\t *  @type array\n\t */\n\t\"aDataSort\": null,\n\n\t/**\n\t * Define the sorting directions that are applied to the column, in sequence\n\t * as the column is repeatedly sorted upon - i.e. the first value is used\n\t * as the sorting direction when the column if first sorted (clicked on).\n\t * Sort it again (click again) and it will move on to the next index.\n\t * Repeat until loop.\n\t *  @type array\n\t */\n\t\"asSorting\": null,\n\n\t/**\n\t * Flag to indicate if the column is searchable, and thus should be included\n\t * in the filtering or not.\n\t *  @type boolean\n\t */\n\t\"bSearchable\": null,\n\n\t/**\n\t * Flag to indicate if the column is sortable or not.\n\t *  @type boolean\n\t */\n\t\"bSortable\": null,\n\n\t/**\n\t * Flag to indicate if the column is currently visible in the table or not\n\t *  @type boolean\n\t */\n\t\"bVisible\": null,\n\n\t/**\n\t * Store for manual type assignment using the `column.type` option. This\n\t * is held in store so we can manipulate the column's `sType` property.\n\t *  @type string\n\t *  @default null\n\t *  @private\n\t */\n\t\"_sManualType\": null,\n\n\t/**\n\t * Flag to indicate if HTML5 data attributes should be used as the data\n\t * source for filtering or sorting. True is either are.\n\t *  @type boolean\n\t *  @default false\n\t *  @private\n\t */\n\t\"_bAttrSrc\": false,\n\n\t/**\n\t * Developer definable function that is called whenever a cell is created (Ajax source,\n\t * etc) or processed for input (DOM source). This can be used as a compliment to mRender\n\t * allowing you to modify the DOM element (add background colour for example) when the\n\t * element is available.\n\t *  @type function\n\t *  @param {element} nTd The TD node that has been created\n\t *  @param {*} sData The Data for the cell\n\t *  @param {array|object} oData The data for the whole row\n\t *  @param {int} iRow The row index for the aoData data store\n\t *  @default null\n\t */\n\t\"fnCreatedCell\": null,\n\n\t/**\n\t * Function to get data from a cell in a column. You should <b>never</b>\n\t * access data directly through _aData internally in DataTables - always use\n\t * the method attached to this property. It allows mData to function as\n\t * required. This function is automatically assigned by the column\n\t * initialisation method\n\t *  @type function\n\t *  @param {array|object} oData The data array/object for the array\n\t *    (i.e. aoData[]._aData)\n\t *  @param {string} sSpecific The specific data type you want to get -\n\t *    'display', 'type' 'filter' 'sort'\n\t *  @returns {*} The data for the cell from the given row's data\n\t *  @default null\n\t */\n\t\"fnGetData\": null,\n\n\t/**\n\t * Function to set data for a cell in the column. You should <b>never</b>\n\t * set the data directly to _aData internally in DataTables - always use\n\t * this method. It allows mData to function as required. This function\n\t * is automatically assigned by the column initialisation method\n\t *  @type function\n\t *  @param {array|object} oData The data array/object for the array\n\t *    (i.e. aoData[]._aData)\n\t *  @param {*} sValue Value to set\n\t *  @default null\n\t */\n\t\"fnSetData\": null,\n\n\t/**\n\t * Property to read the value for the cells in the column from the data\n\t * source array / object. If null, then the default content is used, if a\n\t * function is given then the return from the function is used.\n\t *  @type function|int|string|null\n\t *  @default null\n\t */\n\t\"mData\": null,\n\n\t/**\n\t * Partner property to mData which is used (only when defined) to get\n\t * the data - i.e. it is basically the same as mData, but without the\n\t * 'set' option, and also the data fed to it is the result from mData.\n\t * This is the rendering method to match the data method of mData.\n\t *  @type function|int|string|null\n\t *  @default null\n\t */\n\t\"mRender\": null,\n\n\t/**\n\t * Unique header TH/TD element for this column - this is what the sorting\n\t * listener is attached to (if sorting is enabled.)\n\t *  @type node\n\t *  @default null\n\t */\n\t\"nTh\": null,\n\n\t/**\n\t * Unique footer TH/TD element for this column (if there is one). Not used\n\t * in DataTables as such, but can be used for plug-ins to reference the\n\t * footer for each column.\n\t *  @type node\n\t *  @default null\n\t */\n\t\"nTf\": null,\n\n\t/**\n\t * The class to apply to all TD elements in the table's TBODY for the column\n\t *  @type string\n\t *  @default null\n\t */\n\t\"sClass\": null,\n\n\t/**\n\t * When DataTables calculates the column widths to assign to each column,\n\t * it finds the longest string in each column and then constructs a\n\t * temporary table and reads the widths from that. The problem with this\n\t * is that \"mmm\" is much wider then \"iiii\", but the latter is a longer\n\t * string - thus the calculation can go wrong (doing it properly and putting\n\t * it into an DOM object and measuring that is horribly(!) slow). Thus as\n\t * a \"work around\" we provide this option. It will append its value to the\n\t * text that is found to be the longest string for the column - i.e. padding.\n\t *  @type string\n\t */\n\t\"sContentPadding\": null,\n\n\t/**\n\t * Allows a default value to be given for a column's data, and will be used\n\t * whenever a null data source is encountered (this can be because mData\n\t * is set to null, or because the data source itself is null).\n\t *  @type string\n\t *  @default null\n\t */\n\t\"sDefaultContent\": null,\n\n\t/**\n\t * Name for the column, allowing reference to the column by name as well as\n\t * by index (needs a lookup to work by name).\n\t *  @type string\n\t */\n\t\"sName\": null,\n\n\t/**\n\t * Custom sorting data type - defines which of the available plug-ins in\n\t * afnSortData the custom sorting will use - if any is defined.\n\t *  @type string\n\t *  @default std\n\t */\n\t\"sSortDataType\": 'std',\n\n\t/**\n\t * Class to be applied to the header element when sorting on this column\n\t *  @type string\n\t *  @default null\n\t */\n\t\"sSortingClass\": null,\n\n\t/**\n\t * Class to be applied to the header element when sorting on this column -\n\t * when jQuery UI theming is used.\n\t *  @type string\n\t *  @default null\n\t */\n\t\"sSortingClassJUI\": null,\n\n\t/**\n\t * Title of the column - what is seen in the TH element (nTh).\n\t *  @type string\n\t */\n\t\"sTitle\": null,\n\n\t/**\n\t * Column sorting and filtering type\n\t *  @type string\n\t *  @default null\n\t */\n\t\"sType\": null,\n\n\t/**\n\t * Width of the column\n\t *  @type string\n\t *  @default null\n\t */\n\t\"sWidth\": null,\n\n\t/**\n\t * Width of the column when it was first \"encountered\"\n\t *  @type string\n\t *  @default null\n\t */\n\t\"sWidthOrig\": null\n};\n\n\n/*\n * Developer note: The properties of the object below are given in Hungarian\n * notation, that was used as the interface for DataTables prior to v1.10, however\n * from v1.10 onwards the primary interface is camel case. In order to avoid\n * breaking backwards compatibility utterly with this change, the Hungarian\n * version is still, internally the primary interface, but is is not documented\n * - hence the @name tags in each doc comment. This allows a Javascript function\n * to create a map from Hungarian notation to camel case (going the other direction\n * would require each property to be listed, which would add around 3K to the size\n * of DataTables, while this method is about a 0.5K hit).\n *\n * Ultimately this does pave the way for Hungarian notation to be dropped\n * completely, but that is a massive amount of work and will break current\n * installs (therefore is on-hold until v2).\n */\n\n/**\n * Initialisation options that can be given to DataTables at initialisation\n * time.\n *  @namespace\n */\nDataTable.defaults = {\n\t/**\n\t * An array of data to use for the table, passed in at initialisation which\n\t * will be used in preference to any data which is already in the DOM. This is\n\t * particularly useful for constructing tables purely in Javascript, for\n\t * example with a custom Ajax call.\n\t *  @type array\n\t *  @default null\n\t *\n\t *  @dtopt Option\n\t *  @name DataTable.defaults.data\n\t *\n\t *  @example\n\t *    // Using a 2D array data source\n\t *    $(document).ready( function () {\n\t *      $('#example').dataTable( {\n\t *        \"data\": [\n\t *          ['Trident', 'Internet Explorer 4.0', 'Win 95+', 4, 'X'],\n\t *          ['Trident', 'Internet Explorer 5.0', 'Win 95+', 5, 'C'],\n\t *        ],\n\t *        \"columns\": [\n\t *          { \"title\": \"Engine\" },\n\t *          { \"title\": \"Browser\" },\n\t *          { \"title\": \"Platform\" },\n\t *          { \"title\": \"Version\" },\n\t *          { \"title\": \"Grade\" }\n\t *        ]\n\t *      } );\n\t *    } );\n\t *\n\t *  @example\n\t *    // Using an array of objects as a data source (`data`)\n\t *    $(document).ready( function () {\n\t *      $('#example').dataTable( {\n\t *        \"data\": [\n\t *          {\n\t *            \"engine\":   \"Trident\",\n\t *            \"browser\":  \"Internet Explorer 4.0\",\n\t *            \"platform\": \"Win 95+\",\n\t *            \"version\":  4,\n\t *            \"grade\":    \"X\"\n\t *          },\n\t *          {\n\t *            \"engine\":   \"Trident\",\n\t *            \"browser\":  \"Internet Explorer 5.0\",\n\t *            \"platform\": \"Win 95+\",\n\t *            \"version\":  5,\n\t *            \"grade\":    \"C\"\n\t *          }\n\t *        ],\n\t *        \"columns\": [\n\t *          { \"title\": \"Engine\",   \"data\": \"engine\" },\n\t *          { \"title\": \"Browser\",  \"data\": \"browser\" },\n\t *          { \"title\": \"Platform\", \"data\": \"platform\" },\n\t *          { \"title\": \"Version\",  \"data\": \"version\" },\n\t *          { \"title\": \"Grade\",    \"data\": \"grade\" }\n\t *        ]\n\t *      } );\n\t *    } );\n\t */\n\t\"aaData\": null,\n\n\n\t/**\n\t * If ordering is enabled, then DataTables will perform a first pass sort on\n\t * initialisation. You can define which column(s) the sort is performed\n\t * upon, and the sorting direction, with this variable. The `sorting` array\n\t * should contain an array for each column to be sorted initially containing\n\t * the column's index and a direction string ('asc' or 'desc').\n\t *  @type array\n\t *  @default [[0,'asc']]\n\t *\n\t *  @dtopt Option\n\t *  @name DataTable.defaults.order\n\t *\n\t *  @example\n\t *    // Sort by 3rd column first, and then 4th column\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"order\": [[2,'asc'], [3,'desc']]\n\t *      } );\n\t *    } );\n\t *\n\t *    // No initial sorting\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"order\": []\n\t *      } );\n\t *    } );\n\t */\n\t\"aaSorting\": [[0,'asc']],\n\n\n\t/**\n\t * This parameter is basically identical to the `sorting` parameter, but\n\t * cannot be overridden by user interaction with the table. What this means\n\t * is that you could have a column (visible or hidden) which the sorting\n\t * will always be forced on first - any sorting after that (from the user)\n\t * will then be performed as required. This can be useful for grouping rows\n\t * together.\n\t *  @type array\n\t *  @default null\n\t *\n\t *  @dtopt Option\n\t *  @name DataTable.defaults.orderFixed\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"orderFixed\": [[0,'asc']]\n\t *      } );\n\t *    } )\n\t */\n\t\"aaSortingFixed\": [],\n\n\n\t/**\n\t * DataTables can be instructed to load data to display in the table from a\n\t * Ajax source. This option defines how that Ajax call is made and where to.\n\t *\n\t * The `ajax` property has three different modes of operation, depending on\n\t * how it is defined. These are:\n\t *\n\t * * `string` - Set the URL from where the data should be loaded from.\n\t * * `object` - Define properties for `jQuery.ajax`.\n\t * * `function` - Custom data get function\n\t *\n\t * `string`\n\t * --------\n\t *\n\t * As a string, the `ajax` property simply defines the URL from which\n\t * DataTables will load data.\n\t *\n\t * `object`\n\t * --------\n\t *\n\t * As an object, the parameters in the object are passed to\n\t * [jQuery.ajax](https://api.jquery.com/jQuery.ajax/) allowing fine control\n\t * of the Ajax request. DataTables has a number of default parameters which\n\t * you can override using this option. Please refer to the jQuery\n\t * documentation for a full description of the options available, although\n\t * the following parameters provide additional options in DataTables or\n\t * require special consideration:\n\t *\n\t * * `data` - As with jQuery, `data` can be provided as an object, but it\n\t *   can also be used as a function to manipulate the data DataTables sends\n\t *   to the server. The function takes a single parameter, an object of\n\t *   parameters with the values that DataTables has readied for sending. An\n\t *   object may be returned which will be merged into the DataTables\n\t *   defaults, or you can add the items to the object that was passed in and\n\t *   not return anything from the function. This supersedes `fnServerParams`\n\t *   from DataTables 1.9-.\n\t *\n\t * * `dataSrc` - By default DataTables will look for the property `data` (or\n\t *   `aaData` for compatibility with DataTables 1.9-) when obtaining data\n\t *   from an Ajax source or for server-side processing - this parameter\n\t *   allows that property to be changed. You can use Javascript dotted\n\t *   object notation to get a data source for multiple levels of nesting, or\n\t *   it my be used as a function. As a function it takes a single parameter,\n\t *   the JSON returned from the server, which can be manipulated as\n\t *   required, with the returned value being that used by DataTables as the\n\t *   data source for the table. This supersedes `sAjaxDataProp` from\n\t *   DataTables 1.9-.\n\t *\n\t * * `success` - Should not be overridden it is used internally in\n\t *   DataTables. To manipulate / transform the data returned by the server\n\t *   use `ajax.dataSrc`, or use `ajax` as a function (see below).\n\t *\n\t * `function`\n\t * ----------\n\t *\n\t * As a function, making the Ajax call is left up to yourself allowing\n\t * complete control of the Ajax request. Indeed, if desired, a method other\n\t * than Ajax could be used to obtain the required data, such as Web storage\n\t * or an AIR database.\n\t *\n\t * The function is given four parameters and no return is required. The\n\t * parameters are:\n\t *\n\t * 1. _object_ - Data to send to the server\n\t * 2. _function_ - Callback function that must be executed when the required\n\t *    data has been obtained. That data should be passed into the callback\n\t *    as the only parameter\n\t * 3. _object_ - DataTables settings object for the table\n\t *\n\t * Note that this supersedes `fnServerData` from DataTables 1.9-.\n\t *\n\t *  @type string|object|function\n\t *  @default null\n\t *\n\t *  @dtopt Option\n\t *  @name DataTable.defaults.ajax\n\t *  @since 1.10.0\n\t *\n\t * @example\n\t *   // Get JSON data from a file via Ajax.\n\t *   // Note DataTables expects data in the form `{ data: [ ...data... ] }` by default).\n\t *   $('#example').dataTable( {\n\t *     \"ajax\": \"data.json\"\n\t *   } );\n\t *\n\t * @example\n\t *   // Get JSON data from a file via Ajax, using `dataSrc` to change\n\t *   // `data` to `tableData` (i.e. `{ tableData: [ ...data... ] }`)\n\t *   $('#example').dataTable( {\n\t *     \"ajax\": {\n\t *       \"url\": \"data.json\",\n\t *       \"dataSrc\": \"tableData\"\n\t *     }\n\t *   } );\n\t *\n\t * @example\n\t *   // Get JSON data from a file via Ajax, using `dataSrc` to read data\n\t *   // from a plain array rather than an array in an object\n\t *   $('#example').dataTable( {\n\t *     \"ajax\": {\n\t *       \"url\": \"data.json\",\n\t *       \"dataSrc\": \"\"\n\t *     }\n\t *   } );\n\t *\n\t * @example\n\t *   // Manipulate the data returned from the server - add a link to data\n\t *   // (note this can, should, be done using `render` for the column - this\n\t *   // is just a simple example of how the data can be manipulated).\n\t *   $('#example').dataTable( {\n\t *     \"ajax\": {\n\t *       \"url\": \"data.json\",\n\t *       \"dataSrc\": function ( json ) {\n\t *         for ( var i=0, ien=json.length ; i<ien ; i++ ) {\n\t *           json[i][0] = '<a href=\"/message/'+json[i][0]+'>View message</a>';\n\t *         }\n\t *         return json;\n\t *       }\n\t *     }\n\t *   } );\n\t *\n\t * @example\n\t *   // Add data to the request\n\t *   $('#example').dataTable( {\n\t *     \"ajax\": {\n\t *       \"url\": \"data.json\",\n\t *       \"data\": function ( d ) {\n\t *         return {\n\t *           \"extra_search\": $('#extra').val()\n\t *         };\n\t *       }\n\t *     }\n\t *   } );\n\t *\n\t * @example\n\t *   // Send request as POST\n\t *   $('#example').dataTable( {\n\t *     \"ajax\": {\n\t *       \"url\": \"data.json\",\n\t *       \"type\": \"POST\"\n\t *     }\n\t *   } );\n\t *\n\t * @example\n\t *   // Get the data from localStorage (could interface with a form for\n\t *   // adding, editing and removing rows).\n\t *   $('#example').dataTable( {\n\t *     \"ajax\": function (data, callback, settings) {\n\t *       callback(\n\t *         JSON.parse( localStorage.getItem('dataTablesData') )\n\t *       );\n\t *     }\n\t *   } );\n\t */\n\t\"ajax\": null,\n\n\n\t/**\n\t * This parameter allows you to readily specify the entries in the length drop\n\t * down menu that DataTables shows when pagination is enabled. It can be\n\t * either a 1D array of options which will be used for both the displayed\n\t * option and the value, or a 2D array which will use the array in the first\n\t * position as the value, and the array in the second position as the\n\t * displayed options (useful for language strings such as 'All').\n\t *\n\t * Note that the `pageLength` property will be automatically set to the\n\t * first value given in this array, unless `pageLength` is also provided.\n\t *  @type array\n\t *  @default [ 10, 25, 50, 100 ]\n\t *\n\t *  @dtopt Option\n\t *  @name DataTable.defaults.lengthMenu\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"lengthMenu\": [[10, 25, 50, -1], [10, 25, 50, \"All\"]]\n\t *      } );\n\t *    } );\n\t */\n\t\"aLengthMenu\": [ 10, 25, 50, 100 ],\n\n\n\t/**\n\t * The `columns` option in the initialisation parameter allows you to define\n\t * details about the way individual columns behave. For a full list of\n\t * column options that can be set, please see\n\t * {@link DataTable.defaults.column}. Note that if you use `columns` to\n\t * define your columns, you must have an entry in the array for every single\n\t * column that you have in your table (these can be null if you don't which\n\t * to specify any options).\n\t *  @member\n\t *\n\t *  @name DataTable.defaults.column\n\t */\n\t\"aoColumns\": null,\n\n\t/**\n\t * Very similar to `columns`, `columnDefs` allows you to target a specific\n\t * column, multiple columns, or all columns, using the `targets` property of\n\t * each object in the array. This allows great flexibility when creating\n\t * tables, as the `columnDefs` arrays can be of any length, targeting the\n\t * columns you specifically want. `columnDefs` may use any of the column\n\t * options available: {@link DataTable.defaults.column}, but it _must_\n\t * have `targets` defined in each object in the array. Values in the `targets`\n\t * array may be:\n\t *   <ul>\n\t *     <li>a string - class name will be matched on the TH for the column</li>\n\t *     <li>0 or a positive integer - column index counting from the left</li>\n\t *     <li>a negative integer - column index counting from the right</li>\n\t *     <li>the string \"_all\" - all columns (i.e. assign a default)</li>\n\t *   </ul>\n\t *  @member\n\t *\n\t *  @name DataTable.defaults.columnDefs\n\t */\n\t\"aoColumnDefs\": null,\n\n\n\t/**\n\t * Basically the same as `search`, this parameter defines the individual column\n\t * filtering state at initialisation time. The array must be of the same size\n\t * as the number of columns, and each element be an object with the parameters\n\t * `search` and `escapeRegex` (the latter is optional). 'null' is also\n\t * accepted and the default will be used.\n\t *  @type array\n\t *  @default []\n\t *\n\t *  @dtopt Option\n\t *  @name DataTable.defaults.searchCols\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"searchCols\": [\n\t *          null,\n\t *          { \"search\": \"My filter\" },\n\t *          null,\n\t *          { \"search\": \"^[0-9]\", \"escapeRegex\": false }\n\t *        ]\n\t *      } );\n\t *    } )\n\t */\n\t\"aoSearchCols\": [],\n\n\n\t/**\n\t * An array of CSS classes that should be applied to displayed rows. This\n\t * array may be of any length, and DataTables will apply each class\n\t * sequentially, looping when required.\n\t *  @type array\n\t *  @default null <i>Will take the values determined by the `oClasses.stripe*`\n\t *    options</i>\n\t *\n\t *  @dtopt Option\n\t *  @name DataTable.defaults.stripeClasses\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"stripeClasses\": [ 'strip1', 'strip2', 'strip3' ]\n\t *      } );\n\t *    } )\n\t */\n\t\"asStripeClasses\": null,\n\n\n\t/**\n\t * Enable or disable automatic column width calculation. This can be disabled\n\t * as an optimisation (it takes some time to calculate the widths) if the\n\t * tables widths are passed in using `columns`.\n\t *  @type boolean\n\t *  @default true\n\t *\n\t *  @dtopt Features\n\t *  @name DataTable.defaults.autoWidth\n\t *\n\t *  @example\n\t *    $(document).ready( function () {\n\t *      $('#example').dataTable( {\n\t *        \"autoWidth\": false\n\t *      } );\n\t *    } );\n\t */\n\t\"bAutoWidth\": true,\n\n\n\t/**\n\t * Deferred rendering can provide DataTables with a huge speed boost when you\n\t * are using an Ajax or JS data source for the table. This option, when set to\n\t * true, will cause DataTables to defer the creation of the table elements for\n\t * each row until they are needed for a draw - saving a significant amount of\n\t * time.\n\t *  @type boolean\n\t *  @default false\n\t *\n\t *  @dtopt Features\n\t *  @name DataTable.defaults.deferRender\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"ajax\": \"sources/arrays.txt\",\n\t *        \"deferRender\": true\n\t *      } );\n\t *    } );\n\t */\n\t\"bDeferRender\": false,\n\n\n\t/**\n\t * Replace a DataTable which matches the given selector and replace it with\n\t * one which has the properties of the new initialisation object passed. If no\n\t * table matches the selector, then the new DataTable will be constructed as\n\t * per normal.\n\t *  @type boolean\n\t *  @default false\n\t *\n\t *  @dtopt Options\n\t *  @name DataTable.defaults.destroy\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"srollY\": \"200px\",\n\t *        \"paginate\": false\n\t *      } );\n\t *\n\t *      // Some time later....\n\t *      $('#example').dataTable( {\n\t *        \"filter\": false,\n\t *        \"destroy\": true\n\t *      } );\n\t *    } );\n\t */\n\t\"bDestroy\": false,\n\n\n\t/**\n\t * Enable or disable filtering of data. Filtering in DataTables is \"smart\" in\n\t * that it allows the end user to input multiple words (space separated) and\n\t * will match a row containing those words, even if not in the order that was\n\t * specified (this allow matching across multiple columns). Note that if you\n\t * wish to use filtering in DataTables this must remain 'true' - to remove the\n\t * default filtering input box and retain filtering abilities, please use\n\t * {@link DataTable.defaults.dom}.\n\t *  @type boolean\n\t *  @default true\n\t *\n\t *  @dtopt Features\n\t *  @name DataTable.defaults.searching\n\t *\n\t *  @example\n\t *    $(document).ready( function () {\n\t *      $('#example').dataTable( {\n\t *        \"searching\": false\n\t *      } );\n\t *    } );\n\t */\n\t\"bFilter\": true,\n\n\n\t/**\n\t * Enable or disable the table information display. This shows information\n\t * about the data that is currently visible on the page, including information\n\t * about filtered data if that action is being performed.\n\t *  @type boolean\n\t *  @default true\n\t *\n\t *  @dtopt Features\n\t *  @name DataTable.defaults.info\n\t *\n\t *  @example\n\t *    $(document).ready( function () {\n\t *      $('#example').dataTable( {\n\t *        \"info\": false\n\t *      } );\n\t *    } );\n\t */\n\t\"bInfo\": true,\n\n\n\t/**\n\t * Allows the end user to select the size of a formatted page from a select\n\t * menu (sizes are 10, 25, 50 and 100). Requires pagination (`paginate`).\n\t *  @type boolean\n\t *  @default true\n\t *\n\t *  @dtopt Features\n\t *  @name DataTable.defaults.lengthChange\n\t *\n\t *  @example\n\t *    $(document).ready( function () {\n\t *      $('#example').dataTable( {\n\t *        \"lengthChange\": false\n\t *      } );\n\t *    } );\n\t */\n\t\"bLengthChange\": true,\n\n\n\t/**\n\t * Enable or disable pagination.\n\t *  @type boolean\n\t *  @default true\n\t *\n\t *  @dtopt Features\n\t *  @name DataTable.defaults.paging\n\t *\n\t *  @example\n\t *    $(document).ready( function () {\n\t *      $('#example').dataTable( {\n\t *        \"paging\": false\n\t *      } );\n\t *    } );\n\t */\n\t\"bPaginate\": true,\n\n\n\t/**\n\t * Enable or disable the display of a 'processing' indicator when the table is\n\t * being processed (e.g. a sort). This is particularly useful for tables with\n\t * large amounts of data where it can take a noticeable amount of time to sort\n\t * the entries.\n\t *  @type boolean\n\t *  @default false\n\t *\n\t *  @dtopt Features\n\t *  @name DataTable.defaults.processing\n\t *\n\t *  @example\n\t *    $(document).ready( function () {\n\t *      $('#example').dataTable( {\n\t *        \"processing\": true\n\t *      } );\n\t *    } );\n\t */\n\t\"bProcessing\": false,\n\n\n\t/**\n\t * Retrieve the DataTables object for the given selector. Note that if the\n\t * table has already been initialised, this parameter will cause DataTables\n\t * to simply return the object that has already been set up - it will not take\n\t * account of any changes you might have made to the initialisation object\n\t * passed to DataTables (setting this parameter to true is an acknowledgement\n\t * that you understand this). `destroy` can be used to reinitialise a table if\n\t * you need.\n\t *  @type boolean\n\t *  @default false\n\t *\n\t *  @dtopt Options\n\t *  @name DataTable.defaults.retrieve\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      initTable();\n\t *      tableActions();\n\t *    } );\n\t *\n\t *    function initTable ()\n\t *    {\n\t *      return $('#example').dataTable( {\n\t *        \"scrollY\": \"200px\",\n\t *        \"paginate\": false,\n\t *        \"retrieve\": true\n\t *      } );\n\t *    }\n\t *\n\t *    function tableActions ()\n\t *    {\n\t *      var table = initTable();\n\t *      // perform API operations with oTable\n\t *    }\n\t */\n\t\"bRetrieve\": false,\n\n\n\t/**\n\t * When vertical (y) scrolling is enabled, DataTables will force the height of\n\t * the table's viewport to the given height at all times (useful for layout).\n\t * However, this can look odd when filtering data down to a small data set,\n\t * and the footer is left \"floating\" further down. This parameter (when\n\t * enabled) will cause DataTables to collapse the table's viewport down when\n\t * the result set will fit within the given Y height.\n\t *  @type boolean\n\t *  @default false\n\t *\n\t *  @dtopt Options\n\t *  @name DataTable.defaults.scrollCollapse\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"scrollY\": \"200\",\n\t *        \"scrollCollapse\": true\n\t *      } );\n\t *    } );\n\t */\n\t\"bScrollCollapse\": false,\n\n\n\t/**\n\t * Configure DataTables to use server-side processing. Note that the\n\t * `ajax` parameter must also be given in order to give DataTables a\n\t * source to obtain the required data for each draw.\n\t *  @type boolean\n\t *  @default false\n\t *\n\t *  @dtopt Features\n\t *  @dtopt Server-side\n\t *  @name DataTable.defaults.serverSide\n\t *\n\t *  @example\n\t *    $(document).ready( function () {\n\t *      $('#example').dataTable( {\n\t *        \"serverSide\": true,\n\t *        \"ajax\": \"xhr.php\"\n\t *      } );\n\t *    } );\n\t */\n\t\"bServerSide\": false,\n\n\n\t/**\n\t * Enable or disable sorting of columns. Sorting of individual columns can be\n\t * disabled by the `sortable` option for each column.\n\t *  @type boolean\n\t *  @default true\n\t *\n\t *  @dtopt Features\n\t *  @name DataTable.defaults.ordering\n\t *\n\t *  @example\n\t *    $(document).ready( function () {\n\t *      $('#example').dataTable( {\n\t *        \"ordering\": false\n\t *      } );\n\t *    } );\n\t */\n\t\"bSort\": true,\n\n\n\t/**\n\t * Enable or display DataTables' ability to sort multiple columns at the\n\t * same time (activated by shift-click by the user).\n\t *  @type boolean\n\t *  @default true\n\t *\n\t *  @dtopt Options\n\t *  @name DataTable.defaults.orderMulti\n\t *\n\t *  @example\n\t *    // Disable multiple column sorting ability\n\t *    $(document).ready( function () {\n\t *      $('#example').dataTable( {\n\t *        \"orderMulti\": false\n\t *      } );\n\t *    } );\n\t */\n\t\"bSortMulti\": true,\n\n\n\t/**\n\t * Allows control over whether DataTables should use the top (true) unique\n\t * cell that is found for a single column, or the bottom (false - default).\n\t * This is useful when using complex headers.\n\t *  @type boolean\n\t *  @default false\n\t *\n\t *  @dtopt Options\n\t *  @name DataTable.defaults.orderCellsTop\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"orderCellsTop\": true\n\t *      } );\n\t *    } );\n\t */\n\t\"bSortCellsTop\": false,\n\n\n\t/**\n\t * Enable or disable the addition of the classes `sorting\\_1`, `sorting\\_2` and\n\t * `sorting\\_3` to the columns which are currently being sorted on. This is\n\t * presented as a feature switch as it can increase processing time (while\n\t * classes are removed and added) so for large data sets you might want to\n\t * turn this off.\n\t *  @type boolean\n\t *  @default true\n\t *\n\t *  @dtopt Features\n\t *  @name DataTable.defaults.orderClasses\n\t *\n\t *  @example\n\t *    $(document).ready( function () {\n\t *      $('#example').dataTable( {\n\t *        \"orderClasses\": false\n\t *      } );\n\t *    } );\n\t */\n\t\"bSortClasses\": true,\n\n\n\t/**\n\t * Enable or disable state saving. When enabled HTML5 `localStorage` will be\n\t * used to save table display information such as pagination information,\n\t * display length, filtering and sorting. As such when the end user reloads\n\t * the page the display display will match what thy had previously set up.\n\t *\n\t * Due to the use of `localStorage` the default state saving is not supported\n\t * in IE6 or 7. If state saving is required in those browsers, use\n\t * `stateSaveCallback` to provide a storage solution such as cookies.\n\t *  @type boolean\n\t *  @default false\n\t *\n\t *  @dtopt Features\n\t *  @name DataTable.defaults.stateSave\n\t *\n\t *  @example\n\t *    $(document).ready( function () {\n\t *      $('#example').dataTable( {\n\t *        \"stateSave\": true\n\t *      } );\n\t *    } );\n\t */\n\t\"bStateSave\": false,\n\n\n\t/**\n\t * This function is called when a TR element is created (and all TD child\n\t * elements have been inserted), or registered if using a DOM source, allowing\n\t * manipulation of the TR element (adding classes etc).\n\t *  @type function\n\t *  @param {node} row \"TR\" element for the current row\n\t *  @param {array} data Raw data array for this row\n\t *  @param {int} dataIndex The index of this row in the internal aoData array\n\t *\n\t *  @dtopt Callbacks\n\t *  @name DataTable.defaults.createdRow\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"createdRow\": function( row, data, dataIndex ) {\n\t *          // Bold the grade for all 'A' grade browsers\n\t *          if ( data[4] == \"A\" )\n\t *          {\n\t *            $('td:eq(4)', row).html( '<b>A</b>' );\n\t *          }\n\t *        }\n\t *      } );\n\t *    } );\n\t */\n\t\"fnCreatedRow\": null,\n\n\n\t/**\n\t * This function is called on every 'draw' event, and allows you to\n\t * dynamically modify any aspect you want about the created DOM.\n\t *  @type function\n\t *  @param {object} settings DataTables settings object\n\t *\n\t *  @dtopt Callbacks\n\t *  @name DataTable.defaults.drawCallback\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"drawCallback\": function( settings ) {\n\t *          alert( 'DataTables has redrawn the table' );\n\t *        }\n\t *      } );\n\t *    } );\n\t */\n\t\"fnDrawCallback\": null,\n\n\n\t/**\n\t * Identical to fnHeaderCallback() but for the table footer this function\n\t * allows you to modify the table footer on every 'draw' event.\n\t *  @type function\n\t *  @param {node} foot \"TR\" element for the footer\n\t *  @param {array} data Full table data (as derived from the original HTML)\n\t *  @param {int} start Index for the current display starting point in the\n\t *    display array\n\t *  @param {int} end Index for the current display ending point in the\n\t *    display array\n\t *  @param {array int} display Index array to translate the visual position\n\t *    to the full data array\n\t *\n\t *  @dtopt Callbacks\n\t *  @name DataTable.defaults.footerCallback\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"footerCallback\": function( tfoot, data, start, end, display ) {\n\t *          tfoot.getElementsByTagName('th')[0].innerHTML = \"Starting index is \"+start;\n\t *        }\n\t *      } );\n\t *    } )\n\t */\n\t\"fnFooterCallback\": null,\n\n\n\t/**\n\t * When rendering large numbers in the information element for the table\n\t * (i.e. \"Showing 1 to 10 of 57 entries\") DataTables will render large numbers\n\t * to have a comma separator for the 'thousands' units (e.g. 1 million is\n\t * rendered as \"1,000,000\") to help readability for the end user. This\n\t * function will override the default method DataTables uses.\n\t *  @type function\n\t *  @member\n\t *  @param {int} toFormat number to be formatted\n\t *  @returns {string} formatted string for DataTables to show the number\n\t *\n\t *  @dtopt Callbacks\n\t *  @name DataTable.defaults.formatNumber\n\t *\n\t *  @example\n\t *    // Format a number using a single quote for the separator (note that\n\t *    // this can also be done with the language.thousands option)\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"formatNumber\": function ( toFormat ) {\n\t *          return toFormat.toString().replace(\n\t *            /\\B(?=(\\d{3})+(?!\\d))/g, \"'\"\n\t *          );\n\t *        };\n\t *      } );\n\t *    } );\n\t */\n\t\"fnFormatNumber\": function ( toFormat ) {\n\t\treturn toFormat.toString().replace(\n\t\t\t/\\B(?=(\\d{3})+(?!\\d))/g,\n\t\t\tthis.oLanguage.sThousands\n\t\t);\n\t},\n\n\n\t/**\n\t * This function is called on every 'draw' event, and allows you to\n\t * dynamically modify the header row. This can be used to calculate and\n\t * display useful information about the table.\n\t *  @type function\n\t *  @param {node} head \"TR\" element for the header\n\t *  @param {array} data Full table data (as derived from the original HTML)\n\t *  @param {int} start Index for the current display starting point in the\n\t *    display array\n\t *  @param {int} end Index for the current display ending point in the\n\t *    display array\n\t *  @param {array int} display Index array to translate the visual position\n\t *    to the full data array\n\t *\n\t *  @dtopt Callbacks\n\t *  @name DataTable.defaults.headerCallback\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"fheaderCallback\": function( head, data, start, end, display ) {\n\t *          head.getElementsByTagName('th')[0].innerHTML = \"Displaying \"+(end-start)+\" records\";\n\t *        }\n\t *      } );\n\t *    } )\n\t */\n\t\"fnHeaderCallback\": null,\n\n\n\t/**\n\t * The information element can be used to convey information about the current\n\t * state of the table. Although the internationalisation options presented by\n\t * DataTables are quite capable of dealing with most customisations, there may\n\t * be times where you wish to customise the string further. This callback\n\t * allows you to do exactly that.\n\t *  @type function\n\t *  @param {object} oSettings DataTables settings object\n\t *  @param {int} start Starting position in data for the draw\n\t *  @param {int} end End position in data for the draw\n\t *  @param {int} max Total number of rows in the table (regardless of\n\t *    filtering)\n\t *  @param {int} total Total number of rows in the data set, after filtering\n\t *  @param {string} pre The string that DataTables has formatted using it's\n\t *    own rules\n\t *  @returns {string} The string to be displayed in the information element.\n\t *\n\t *  @dtopt Callbacks\n\t *  @name DataTable.defaults.infoCallback\n\t *\n\t *  @example\n\t *    $('#example').dataTable( {\n\t *      \"infoCallback\": function( settings, start, end, max, total, pre ) {\n\t *        return start +\" to \"+ end;\n\t *      }\n\t *    } );\n\t */\n\t\"fnInfoCallback\": null,\n\n\n\t/**\n\t * Called when the table has been initialised. Normally DataTables will\n\t * initialise sequentially and there will be no need for this function,\n\t * however, this does not hold true when using external language information\n\t * since that is obtained using an async XHR call.\n\t *  @type function\n\t *  @param {object} settings 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\n\t *\n\t *  @dtopt Callbacks\n\t *  @name DataTable.defaults.initComplete\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"initComplete\": function(settings, json) {\n\t *          alert( 'DataTables has finished its initialisation.' );\n\t *        }\n\t *      } );\n\t *    } )\n\t */\n\t\"fnInitComplete\": null,\n\n\n\t/**\n\t * Called at the very start of each table draw and can be used to cancel the\n\t * draw by returning false, any other return (including undefined) results in\n\t * the full draw occurring).\n\t *  @type function\n\t *  @param {object} settings DataTables settings object\n\t *  @returns {boolean} False will cancel the draw, anything else (including no\n\t *    return) will allow it to complete.\n\t *\n\t *  @dtopt Callbacks\n\t *  @name DataTable.defaults.preDrawCallback\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"preDrawCallback\": function( settings ) {\n\t *          if ( $('#test').val() == 1 ) {\n\t *            return false;\n\t *          }\n\t *        }\n\t *      } );\n\t *    } );\n\t */\n\t\"fnPreDrawCallback\": null,\n\n\n\t/**\n\t * This function allows you to 'post process' each row after it have been\n\t * generated for each table draw, but before it is rendered on screen. This\n\t * function might be used for setting the row class name etc.\n\t *  @type function\n\t *  @param {node} row \"TR\" element for the current row\n\t *  @param {array} data Raw data array for this row\n\t *  @param {int} displayIndex The display index for the current table draw\n\t *  @param {int} displayIndexFull The index of the data in the full list of\n\t *    rows (after filtering)\n\t *\n\t *  @dtopt Callbacks\n\t *  @name DataTable.defaults.rowCallback\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"rowCallback\": function( row, data, displayIndex, displayIndexFull ) {\n\t *          // Bold the grade for all 'A' grade browsers\n\t *          if ( data[4] == \"A\" ) {\n\t *            $('td:eq(4)', row).html( '<b>A</b>' );\n\t *          }\n\t *        }\n\t *      } );\n\t *    } );\n\t */\n\t\"fnRowCallback\": null,\n\n\n\t/**\n\t * __Deprecated__ The functionality provided by this parameter has now been\n\t * superseded by that provided through `ajax`, which should be used instead.\n\t *\n\t * This parameter allows you to override the default function which obtains\n\t * the data from the server so something more suitable for your application.\n\t * For example you could use POST data, or pull information from a Gears or\n\t * AIR database.\n\t *  @type function\n\t *  @member\n\t *  @param {string} source HTTP source to obtain the data from (`ajax`)\n\t *  @param {array} data A key/value pair object containing the data to send\n\t *    to the server\n\t *  @param {function} callback to be called on completion of the data get\n\t *    process that will draw the data on the page.\n\t *  @param {object} settings DataTables settings object\n\t *\n\t *  @dtopt Callbacks\n\t *  @dtopt Server-side\n\t *  @name DataTable.defaults.serverData\n\t *\n\t *  @deprecated 1.10. Please use `ajax` for this functionality now.\n\t */\n\t\"fnServerData\": null,\n\n\n\t/**\n\t * __Deprecated__ The functionality provided by this parameter has now been\n\t * superseded by that provided through `ajax`, which should be used instead.\n\t *\n\t *  It is often useful to send extra data to the server when making an Ajax\n\t * request - for example custom filtering information, and this callback\n\t * function makes it trivial to send extra information to the server. The\n\t * passed in parameter is the data set that has been constructed by\n\t * DataTables, and you can add to this or modify it as you require.\n\t *  @type function\n\t *  @param {array} data Data array (array of objects which are name/value\n\t *    pairs) that has been constructed by DataTables and will be sent to the\n\t *    server. In the case of Ajax sourced data with server-side processing\n\t *    this will be an empty array, for server-side processing there will be a\n\t *    significant number of parameters!\n\t *  @returns {undefined} Ensure that you modify the data array passed in,\n\t *    as this is passed by reference.\n\t *\n\t *  @dtopt Callbacks\n\t *  @dtopt Server-side\n\t *  @name DataTable.defaults.serverParams\n\t *\n\t *  @deprecated 1.10. Please use `ajax` for this functionality now.\n\t */\n\t\"fnServerParams\": null,\n\n\n\t/**\n\t * Load the table state. With this function you can define from where, and how, the\n\t * state of a table is loaded. By default DataTables will load from `localStorage`\n\t * but you might wish to use a server-side database or cookies.\n\t *  @type function\n\t *  @member\n\t *  @param {object} settings DataTables settings object\n\t *  @param {object} callback Callback that can be executed when done. It\n\t *    should be passed the loaded state object.\n\t *  @return {object} The DataTables state object to be loaded\n\t *\n\t *  @dtopt Callbacks\n\t *  @name DataTable.defaults.stateLoadCallback\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"stateSave\": true,\n\t *        \"stateLoadCallback\": function (settings, callback) {\n\t *          $.ajax( {\n\t *            \"url\": \"/state_load\",\n\t *            \"dataType\": \"json\",\n\t *            \"success\": function (json) {\n\t *              callback( json );\n\t *            }\n\t *          } );\n\t *        }\n\t *      } );\n\t *    } );\n\t */\n\t\"fnStateLoadCallback\": function ( settings ) {\n\t\ttry {\n\t\t\treturn JSON.parse(\n\t\t\t\t(settings.iStateDuration === -1 ? sessionStorage : localStorage).getItem(\n\t\t\t\t\t'DataTables_'+settings.sInstance+'_'+location.pathname\n\t\t\t\t)\n\t\t\t);\n\t\t} catch (e) {\n\t\t\treturn {};\n\t\t}\n\t},\n\n\n\t/**\n\t * Callback which allows modification of the saved state prior to loading that state.\n\t * This callback is called when the table is loading state from the stored data, but\n\t * prior to the settings object being modified by the saved state. Note that for\n\t * plug-in authors, you should use the `stateLoadParams` event to load parameters for\n\t * a plug-in.\n\t *  @type function\n\t *  @param {object} settings DataTables settings object\n\t *  @param {object} data The state object that is to be loaded\n\t *\n\t *  @dtopt Callbacks\n\t *  @name DataTable.defaults.stateLoadParams\n\t *\n\t *  @example\n\t *    // Remove a saved filter, so filtering is never loaded\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"stateSave\": true,\n\t *        \"stateLoadParams\": function (settings, data) {\n\t *          data.oSearch.sSearch = \"\";\n\t *        }\n\t *      } );\n\t *    } );\n\t *\n\t *  @example\n\t *    // Disallow state loading by returning false\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"stateSave\": true,\n\t *        \"stateLoadParams\": function (settings, data) {\n\t *          return false;\n\t *        }\n\t *      } );\n\t *    } );\n\t */\n\t\"fnStateLoadParams\": null,\n\n\n\t/**\n\t * Callback that is called when the state has been loaded from the state saving method\n\t * and the DataTables settings object has been modified as a result of the loaded state.\n\t *  @type function\n\t *  @param {object} settings DataTables settings object\n\t *  @param {object} data The state object that was loaded\n\t *\n\t *  @dtopt Callbacks\n\t *  @name DataTable.defaults.stateLoaded\n\t *\n\t *  @example\n\t *    // Show an alert with the filtering value that was saved\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"stateSave\": true,\n\t *        \"stateLoaded\": function (settings, data) {\n\t *          alert( 'Saved filter was: '+data.oSearch.sSearch );\n\t *        }\n\t *      } );\n\t *    } );\n\t */\n\t\"fnStateLoaded\": null,\n\n\n\t/**\n\t * Save the table state. This function allows you to define where and how the state\n\t * information for the table is stored By default DataTables will use `localStorage`\n\t * but you might wish to use a server-side database or cookies.\n\t *  @type function\n\t *  @member\n\t *  @param {object} settings DataTables settings object\n\t *  @param {object} data The state object to be saved\n\t *\n\t *  @dtopt Callbacks\n\t *  @name DataTable.defaults.stateSaveCallback\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"stateSave\": true,\n\t *        \"stateSaveCallback\": function (settings, data) {\n\t *          // Send an Ajax request to the server with the state object\n\t *          $.ajax( {\n\t *            \"url\": \"/state_save\",\n\t *            \"data\": data,\n\t *            \"dataType\": \"json\",\n\t *            \"method\": \"POST\"\n\t *            \"success\": function () {}\n\t *          } );\n\t *        }\n\t *      } );\n\t *    } );\n\t */\n\t\"fnStateSaveCallback\": function ( settings, data ) {\n\t\ttry {\n\t\t\t(settings.iStateDuration === -1 ? sessionStorage : localStorage).setItem(\n\t\t\t\t'DataTables_'+settings.sInstance+'_'+location.pathname,\n\t\t\t\tJSON.stringify( data )\n\t\t\t);\n\t\t} catch (e) {}\n\t},\n\n\n\t/**\n\t * Callback which allows modification of the state to be saved. Called when the table\n\t * has changed state a new state save is required. This method allows modification of\n\t * the state saving object prior to actually doing the save, including addition or\n\t * other state properties or modification. Note that for plug-in authors, you should\n\t * use the `stateSaveParams` event to save parameters for a plug-in.\n\t *  @type function\n\t *  @param {object} settings DataTables settings object\n\t *  @param {object} data The state object to be saved\n\t *\n\t *  @dtopt Callbacks\n\t *  @name DataTable.defaults.stateSaveParams\n\t *\n\t *  @example\n\t *    // Remove a saved filter, so filtering is never saved\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"stateSave\": true,\n\t *        \"stateSaveParams\": function (settings, data) {\n\t *          data.oSearch.sSearch = \"\";\n\t *        }\n\t *      } );\n\t *    } );\n\t */\n\t\"fnStateSaveParams\": null,\n\n\n\t/**\n\t * Duration for which the saved state information is considered valid. After this period\n\t * has elapsed the state will be returned to the default.\n\t * Value is given in seconds.\n\t *  @type int\n\t *  @default 7200 <i>(2 hours)</i>\n\t *\n\t *  @dtopt Options\n\t *  @name DataTable.defaults.stateDuration\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"stateDuration\": 60*60*24; // 1 day\n\t *      } );\n\t *    } )\n\t */\n\t\"iStateDuration\": 7200,\n\n\n\t/**\n\t * When enabled DataTables will not make a request to the server for the first\n\t * page draw - rather it will use the data already on the page (no sorting etc\n\t * will be applied to it), thus saving on an XHR at load time. `deferLoading`\n\t * is used to indicate that deferred loading is required, but it is also used\n\t * to tell DataTables how many records there are in the full table (allowing\n\t * the information element and pagination to be displayed correctly). In the case\n\t * where a filtering is applied to the table on initial load, this can be\n\t * indicated by giving the parameter as an array, where the first element is\n\t * the number of records available after filtering and the second element is the\n\t * number of records without filtering (allowing the table information element\n\t * to be shown correctly).\n\t *  @type int | array\n\t *  @default null\n\t *\n\t *  @dtopt Options\n\t *  @name DataTable.defaults.deferLoading\n\t *\n\t *  @example\n\t *    // 57 records available in the table, no filtering applied\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"serverSide\": true,\n\t *        \"ajax\": \"scripts/server_processing.php\",\n\t *        \"deferLoading\": 57\n\t *      } );\n\t *    } );\n\t *\n\t *  @example\n\t *    // 57 records after filtering, 100 without filtering (an initial filter applied)\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"serverSide\": true,\n\t *        \"ajax\": \"scripts/server_processing.php\",\n\t *        \"deferLoading\": [ 57, 100 ],\n\t *        \"search\": {\n\t *          \"search\": \"my_filter\"\n\t *        }\n\t *      } );\n\t *    } );\n\t */\n\t\"iDeferLoading\": null,\n\n\n\t/**\n\t * Number of rows to display on a single page when using pagination. If\n\t * feature enabled (`lengthChange`) then the end user will be able to override\n\t * this to a custom setting using a pop-up menu.\n\t *  @type int\n\t *  @default 10\n\t *\n\t *  @dtopt Options\n\t *  @name DataTable.defaults.pageLength\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"pageLength\": 50\n\t *      } );\n\t *    } )\n\t */\n\t\"iDisplayLength\": 10,\n\n\n\t/**\n\t * Define the starting point for data display when using DataTables with\n\t * pagination. Note that this parameter is the number of records, rather than\n\t * the page number, so if you have 10 records per page and want to start on\n\t * the third page, it should be \"20\".\n\t *  @type int\n\t *  @default 0\n\t *\n\t *  @dtopt Options\n\t *  @name DataTable.defaults.displayStart\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"displayStart\": 20\n\t *      } );\n\t *    } )\n\t */\n\t\"iDisplayStart\": 0,\n\n\n\t/**\n\t * By default DataTables allows keyboard navigation of the table (sorting, paging,\n\t * and filtering) by adding a `tabindex` attribute to the required elements. This\n\t * allows you to tab through the controls and press the enter key to activate them.\n\t * The tabindex is default 0, meaning that the tab follows the flow of the document.\n\t * You can overrule this using this parameter if you wish. Use a value of -1 to\n\t * disable built-in keyboard navigation.\n\t *  @type int\n\t *  @default 0\n\t *\n\t *  @dtopt Options\n\t *  @name DataTable.defaults.tabIndex\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"tabIndex\": 1\n\t *      } );\n\t *    } );\n\t */\n\t\"iTabIndex\": 0,\n\n\n\t/**\n\t * Classes that DataTables assigns to the various components and features\n\t * that it adds to the HTML table. This allows classes to be configured\n\t * during initialisation in addition to through the static\n\t * {@link DataTable.ext.oStdClasses} object).\n\t *  @namespace\n\t *  @name DataTable.defaults.classes\n\t */\n\t\"oClasses\": {},\n\n\n\t/**\n\t * All strings that DataTables uses in the user interface that it creates\n\t * are defined in this object, allowing you to modified them individually or\n\t * completely replace them all as required.\n\t *  @namespace\n\t *  @name DataTable.defaults.language\n\t */\n\t\"oLanguage\": {\n\t\t/**\n\t\t * Strings that are used for WAI-ARIA labels and controls only (these are not\n\t\t * actually visible on the page, but will be read by screenreaders, and thus\n\t\t * must be internationalised as well).\n\t\t *  @namespace\n\t\t *  @name DataTable.defaults.language.aria\n\t\t */\n\t\t\"oAria\": {\n\t\t\t/**\n\t\t\t * ARIA label that is added to the table headers when the column may be\n\t\t\t * sorted ascending by activing the column (click or return when focused).\n\t\t\t * Note that the column header is prefixed to this string.\n\t\t\t *  @type string\n\t\t\t *  @default : activate to sort column ascending\n\t\t\t *\n\t\t\t *  @dtopt Language\n\t\t\t *  @name DataTable.defaults.language.aria.sortAscending\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 *          \"aria\": {\n\t\t\t *            \"sortAscending\": \" - click/return to sort ascending\"\n\t\t\t *          }\n\t\t\t *        }\n\t\t\t *      } );\n\t\t\t *    } );\n\t\t\t */\n\t\t\t\"sSortAscending\": \": activate to sort column ascending\",\n\n\t\t\t/**\n\t\t\t * ARIA label that is added to the table headers when the column may be\n\t\t\t * sorted descending by activing the column (click or return when focused).\n\t\t\t * Note that the column header is prefixed to this string.\n\t\t\t *  @type string\n\t\t\t *  @default : activate to sort column ascending\n\t\t\t *\n\t\t\t *  @dtopt Language\n\t\t\t *  @name DataTable.defaults.language.aria.sortDescending\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 *          \"aria\": {\n\t\t\t *            \"sortDescending\": \" - click/return to sort descending\"\n\t\t\t *          }\n\t\t\t *        }\n\t\t\t *      } );\n\t\t\t *    } );\n\t\t\t */\n\t\t\t\"sSortDescending\": \": activate to sort column descending\"\n\t\t},\n\n\t\t/**\n\t\t * Pagination string used by DataTables for the built-in pagination\n\t\t * control types.\n\t\t *  @namespace\n\t\t *  @name DataTable.defaults.language.paginate\n\t\t */\n\t\t\"oPaginate\": {\n\t\t\t/**\n\t\t\t * Text to use when using the 'full_numbers' type of pagination for the\n\t\t\t * button to take the user to the first page.\n\t\t\t *  @type string\n\t\t\t *  @default First\n\t\t\t *\n\t\t\t *  @dtopt Language\n\t\t\t *  @name DataTable.defaults.language.paginate.first\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 *          \"paginate\": {\n\t\t\t *            \"first\": \"First page\"\n\t\t\t *          }\n\t\t\t *        }\n\t\t\t *      } );\n\t\t\t *    } );\n\t\t\t */\n\t\t\t\"sFirst\": \"First\",\n\n\n\t\t\t/**\n\t\t\t * Text to use when using the 'full_numbers' type of pagination for the\n\t\t\t * button to take the user to the last page.\n\t\t\t *  @type string\n\t\t\t *  @default Last\n\t\t\t *\n\t\t\t *  @dtopt Language\n\t\t\t *  @name DataTable.defaults.language.paginate.last\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 *          \"paginate\": {\n\t\t\t *            \"last\": \"Last page\"\n\t\t\t *          }\n\t\t\t *        }\n\t\t\t *      } );\n\t\t\t *    } );\n\t\t\t */\n\t\t\t\"sLast\": \"Last\",\n\n\n\t\t\t/**\n\t\t\t * Text to use for the 'next' pagination button (to take the user to the\n\t\t\t * next page).\n\t\t\t *  @type string\n\t\t\t *  @default Next\n\t\t\t *\n\t\t\t *  @dtopt Language\n\t\t\t *  @name DataTable.defaults.language.paginate.next\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 *          \"paginate\": {\n\t\t\t *            \"next\": \"Next page\"\n\t\t\t *          }\n\t\t\t *        }\n\t\t\t *      } );\n\t\t\t *    } );\n\t\t\t */\n\t\t\t\"sNext\": \"Next\",\n\n\n\t\t\t/**\n\t\t\t * Text to use for the 'previous' pagination button (to take the user to\n\t\t\t * the previous page).\n\t\t\t *  @type string\n\t\t\t *  @default Previous\n\t\t\t *\n\t\t\t *  @dtopt Language\n\t\t\t *  @name DataTable.defaults.language.paginate.previous\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 *          \"paginate\": {\n\t\t\t *            \"previous\": \"Previous page\"\n\t\t\t *          }\n\t\t\t *        }\n\t\t\t *      } );\n\t\t\t *    } );\n\t\t\t */\n\t\t\t\"sPrevious\": \"Previous\"\n\t\t},\n\n\t\t/**\n\t\t * This string is shown in preference to `zeroRecords` when the table is\n\t\t * empty of data (regardless of filtering). Note that this is an optional\n\t\t * parameter - if it is not given, the value of `zeroRecords` will be used\n\t\t * instead (either the default or given value).\n\t\t *  @type string\n\t\t *  @default No data available in table\n\t\t *\n\t\t *  @dtopt Language\n\t\t *  @name DataTable.defaults.language.emptyTable\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"language\": {\n\t\t *          \"emptyTable\": \"No data available in table\"\n\t\t *        }\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"sEmptyTable\": \"No data available in table\",\n\n\n\t\t/**\n\t\t * This string gives information to the end user about the information\n\t\t * that is current on display on the page. The following tokens can be\n\t\t * used in the string and will be dynamically replaced as the table\n\t\t * display updates. This tokens can be placed anywhere in the string, or\n\t\t * removed as needed by the language requires:\n\t\t *\n\t\t * * `\\_START\\_` - Display index of the first record on the current page\n\t\t * * `\\_END\\_` - Display index of the last record on the current page\n\t\t * * `\\_TOTAL\\_` - Number of records in the table after filtering\n\t\t * * `\\_MAX\\_` - Number of records in the table without filtering\n\t\t * * `\\_PAGE\\_` - Current page number\n\t\t * * `\\_PAGES\\_` - Total number of pages of data in the table\n\t\t *\n\t\t *  @type string\n\t\t *  @default Showing _START_ to _END_ of _TOTAL_ entries\n\t\t *\n\t\t *  @dtopt Language\n\t\t *  @name DataTable.defaults.language.info\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"language\": {\n\t\t *          \"info\": \"Showing page _PAGE_ of _PAGES_\"\n\t\t *        }\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"sInfo\": \"Showing _START_ to _END_ of _TOTAL_ entries\",\n\n\n\t\t/**\n\t\t * Display information string for when the table is empty. Typically the\n\t\t * format of this string should match `info`.\n\t\t *  @type string\n\t\t *  @default Showing 0 to 0 of 0 entries\n\t\t *\n\t\t *  @dtopt Language\n\t\t *  @name DataTable.defaults.language.infoEmpty\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"language\": {\n\t\t *          \"infoEmpty\": \"No entries to show\"\n\t\t *        }\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"sInfoEmpty\": \"Showing 0 to 0 of 0 entries\",\n\n\n\t\t/**\n\t\t * When a user filters the information in a table, this string is appended\n\t\t * to the information (`info`) to give an idea of how strong the filtering\n\t\t * is. The variable _MAX_ is dynamically updated.\n\t\t *  @type string\n\t\t *  @default (filtered from _MAX_ total entries)\n\t\t *\n\t\t *  @dtopt Language\n\t\t *  @name DataTable.defaults.language.infoFiltered\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"language\": {\n\t\t *          \"infoFiltered\": \" - filtering from _MAX_ records\"\n\t\t *        }\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"sInfoFiltered\": \"(filtered from _MAX_ total entries)\",\n\n\n\t\t/**\n\t\t * If can be useful to append extra information to the info string at times,\n\t\t * and this variable does exactly that. This information will be appended to\n\t\t * the `info` (`infoEmpty` and `infoFiltered` in whatever combination they are\n\t\t * being used) at all times.\n\t\t *  @type string\n\t\t *  @default <i>Empty string</i>\n\t\t *\n\t\t *  @dtopt Language\n\t\t *  @name DataTable.defaults.language.infoPostFix\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"language\": {\n\t\t *          \"infoPostFix\": \"All records shown are derived from real information.\"\n\t\t *        }\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"sInfoPostFix\": \"\",\n\n\n\t\t/**\n\t\t * This decimal place operator is a little different from the other\n\t\t * language options since DataTables doesn't output floating point\n\t\t * numbers, so it won't ever use this for display of a number. Rather,\n\t\t * what this parameter does is modify the sort methods of the table so\n\t\t * that numbers which are in a format which has a character other than\n\t\t * a period (`.`) as a decimal place will be sorted numerically.\n\t\t *\n\t\t * Note that numbers with different decimal places cannot be shown in\n\t\t * the same table and still be sortable, the table must be consistent.\n\t\t * However, multiple different tables on the page can use different\n\t\t * decimal place characters.\n\t\t *  @type string\n\t\t *  @default \n\t\t *\n\t\t *  @dtopt Language\n\t\t *  @name DataTable.defaults.language.decimal\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"language\": {\n\t\t *          \"decimal\": \",\"\n\t\t *          \"thousands\": \".\"\n\t\t *        }\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"sDecimal\": \"\",\n\n\n\t\t/**\n\t\t * DataTables has a build in number formatter (`formatNumber`) which is\n\t\t * used to format large numbers that are used in the table information.\n\t\t * By default a comma is used, but this can be trivially changed to any\n\t\t * character you wish with this parameter.\n\t\t *  @type string\n\t\t *  @default ,\n\t\t *\n\t\t *  @dtopt Language\n\t\t *  @name DataTable.defaults.language.thousands\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"language\": {\n\t\t *          \"thousands\": \"'\"\n\t\t *        }\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"sThousands\": \",\",\n\n\n\t\t/**\n\t\t * Detail the action that will be taken when the drop down menu for the\n\t\t * pagination length option is changed. The '_MENU_' variable is replaced\n\t\t * with a default select list of 10, 25, 50 and 100, and can be replaced\n\t\t * with a custom select box if required.\n\t\t *  @type string\n\t\t *  @default Show _MENU_ entries\n\t\t *\n\t\t *  @dtopt Language\n\t\t *  @name DataTable.defaults.language.lengthMenu\n\t\t *\n\t\t *  @example\n\t\t *    // Language change only\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"language\": {\n\t\t *          \"lengthMenu\": \"Display _MENU_ records\"\n\t\t *        }\n\t\t *      } );\n\t\t *    } );\n\t\t *\n\t\t *  @example\n\t\t *    // Language and options change\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"language\": {\n\t\t *          \"lengthMenu\": 'Display <select>'+\n\t\t *            '<option value=\"10\">10</option>'+\n\t\t *            '<option value=\"20\">20</option>'+\n\t\t *            '<option value=\"30\">30</option>'+\n\t\t *            '<option value=\"40\">40</option>'+\n\t\t *            '<option value=\"50\">50</option>'+\n\t\t *            '<option value=\"-1\">All</option>'+\n\t\t *            '</select> records'\n\t\t *        }\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"sLengthMenu\": \"Show _MENU_ entries\",\n\n\n\t\t/**\n\t\t * When using Ajax sourced data and during the first draw when DataTables is\n\t\t * gathering the data, this message is shown in an empty row in the table to\n\t\t * indicate to the end user the the data is being loaded. Note that this\n\t\t * parameter is not used when loading data by server-side processing, just\n\t\t * Ajax sourced data with client-side processing.\n\t\t *  @type string\n\t\t *  @default Loading...\n\t\t *\n\t\t *  @dtopt Language\n\t\t *  @name DataTable.defaults.language.loadingRecords\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"language\": {\n\t\t *          \"loadingRecords\": \"Please wait - loading...\"\n\t\t *        }\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"sLoadingRecords\": \"Loading...\",\n\n\n\t\t/**\n\t\t * Text which is displayed when the table is processing a user action\n\t\t * (usually a sort command or similar).\n\t\t *  @type string\n\t\t *\n\t\t *  @dtopt Language\n\t\t *  @name DataTable.defaults.language.processing\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"language\": {\n\t\t *          \"processing\": \"DataTables is currently busy\"\n\t\t *        }\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"sProcessing\": \"\",\n\n\n\t\t/**\n\t\t * Details the actions that will be taken when the user types into the\n\t\t * filtering input text box. The variable \"_INPUT_\", if used in the string,\n\t\t * is replaced with the HTML text box for the filtering input allowing\n\t\t * control over where it appears in the string. If \"_INPUT_\" is not given\n\t\t * then the input box is appended to the string automatically.\n\t\t *  @type string\n\t\t *  @default Search:\n\t\t *\n\t\t *  @dtopt Language\n\t\t *  @name DataTable.defaults.language.search\n\t\t *\n\t\t *  @example\n\t\t *    // Input text box will be appended at the end automatically\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"language\": {\n\t\t *          \"search\": \"Filter records:\"\n\t\t *        }\n\t\t *      } );\n\t\t *    } );\n\t\t *\n\t\t *  @example\n\t\t *    // Specify where the filter should appear\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"language\": {\n\t\t *          \"search\": \"Apply filter _INPUT_ to table\"\n\t\t *        }\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"sSearch\": \"Search:\",\n\n\n\t\t/**\n\t\t * Assign a `placeholder` attribute to the search `input` element\n\t\t *  @type string\n\t\t *  @default \n\t\t *\n\t\t *  @dtopt Language\n\t\t *  @name DataTable.defaults.language.searchPlaceholder\n\t\t */\n\t\t\"sSearchPlaceholder\": \"\",\n\n\n\t\t/**\n\t\t * All of the language information can be stored in a file on the\n\t\t * server-side, which DataTables will look up if this parameter is passed.\n\t\t * It must store the URL of the language file, which is in a JSON format,\n\t\t * and the object has the same properties as the oLanguage object in the\n\t\t * initialiser object (i.e. the above parameters). Please refer to one of\n\t\t * the example language files to see how this works in action.\n\t\t *  @type string\n\t\t *  @default <i>Empty string - i.e. disabled</i>\n\t\t *\n\t\t *  @dtopt Language\n\t\t *  @name DataTable.defaults.language.url\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"language\": {\n\t\t *          \"url\": \"https://www.sprymedia.co.uk/dataTables/lang.txt\"\n\t\t *        }\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"sUrl\": \"\",\n\n\n\t\t/**\n\t\t * Text shown inside the table records when the is no information to be\n\t\t * displayed after filtering. `emptyTable` is shown when there is simply no\n\t\t * information in the table at all (regardless of filtering).\n\t\t *  @type string\n\t\t *  @default No matching records found\n\t\t *\n\t\t *  @dtopt Language\n\t\t *  @name DataTable.defaults.language.zeroRecords\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"language\": {\n\t\t *          \"zeroRecords\": \"No records to display\"\n\t\t *        }\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"sZeroRecords\": \"No matching records found\"\n\t},\n\n\n\t/**\n\t * This parameter allows you to have define the global filtering state at\n\t * initialisation time. As an object the `search` parameter must be\n\t * defined, but all other parameters are optional. When `regex` is true,\n\t * the search string will be treated as a regular expression, when false\n\t * (default) it will be treated as a straight string. When `smart`\n\t * DataTables will use it's smart filtering methods (to word match at\n\t * any point in the data), when false this will not be done.\n\t *  @namespace\n\t *  @extends DataTable.models.oSearch\n\t *\n\t *  @dtopt Options\n\t *  @name DataTable.defaults.search\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"search\": {\"search\": \"Initial search\"}\n\t *      } );\n\t *    } )\n\t */\n\t\"oSearch\": $.extend( {}, DataTable.models.oSearch ),\n\n\n\t/**\n\t * __Deprecated__ The functionality provided by this parameter has now been\n\t * superseded by that provided through `ajax`, which should be used instead.\n\t *\n\t * By default DataTables will look for the property `data` (or `aaData` for\n\t * compatibility with DataTables 1.9-) when obtaining data from an Ajax\n\t * source or for server-side processing - this parameter allows that\n\t * property to be changed. You can use Javascript dotted object notation to\n\t * get a data source for multiple levels of nesting.\n\t *  @type string\n\t *  @default data\n\t *\n\t *  @dtopt Options\n\t *  @dtopt Server-side\n\t *  @name DataTable.defaults.ajaxDataProp\n\t *\n\t *  @deprecated 1.10. Please use `ajax` for this functionality now.\n\t */\n\t\"sAjaxDataProp\": \"data\",\n\n\n\t/**\n\t * __Deprecated__ The functionality provided by this parameter has now been\n\t * superseded by that provided through `ajax`, which should be used instead.\n\t *\n\t * You can instruct DataTables to load data from an external\n\t * source using this parameter (use aData if you want to pass data in you\n\t * already have). Simply provide a url a JSON object can be obtained from.\n\t *  @type string\n\t *  @default null\n\t *\n\t *  @dtopt Options\n\t *  @dtopt Server-side\n\t *  @name DataTable.defaults.ajaxSource\n\t *\n\t *  @deprecated 1.10. Please use `ajax` for this functionality now.\n\t */\n\t\"sAjaxSource\": null,\n\n\n\t/**\n\t * This initialisation variable allows you to specify exactly where in the\n\t * DOM you want DataTables to inject the various controls it adds to the page\n\t * (for example you might want the pagination controls at the top of the\n\t * table). DIV elements (with or without a custom class) can also be added to\n\t * aid styling. The follow syntax is used:\n\t *   <ul>\n\t *     <li>The following options are allowed:\n\t *       <ul>\n\t *         <li>'l' - Length changing</li>\n\t *         <li>'f' - Filtering input</li>\n\t *         <li>'t' - The table!</li>\n\t *         <li>'i' - Information</li>\n\t *         <li>'p' - Pagination</li>\n\t *         <li>'r' - pRocessing</li>\n\t *       </ul>\n\t *     </li>\n\t *     <li>The following constants are allowed:\n\t *       <ul>\n\t *         <li>'H' - jQueryUI theme \"header\" classes ('fg-toolbar ui-widget-header ui-corner-tl ui-corner-tr ui-helper-clearfix')</li>\n\t *         <li>'F' - jQueryUI theme \"footer\" classes ('fg-toolbar ui-widget-header ui-corner-bl ui-corner-br ui-helper-clearfix')</li>\n\t *       </ul>\n\t *     </li>\n\t *     <li>The following syntax is expected:\n\t *       <ul>\n\t *         <li>'&lt;' and '&gt;' - div elements</li>\n\t *         <li>'&lt;\"class\" and '&gt;' - div with a class</li>\n\t *         <li>'&lt;\"#id\" and '&gt;' - div with an ID</li>\n\t *       </ul>\n\t *     </li>\n\t *     <li>Examples:\n\t *       <ul>\n\t *         <li>'&lt;\"wrapper\"flipt&gt;'</li>\n\t *         <li>'&lt;lf&lt;t&gt;ip&gt;'</li>\n\t *       </ul>\n\t *     </li>\n\t *   </ul>\n\t *  @type string\n\t *  @default lfrtip <i>(when `jQueryUI` is false)</i> <b>or</b>\n\t *    <\"H\"lfr>t<\"F\"ip> <i>(when `jQueryUI` is true)</i>\n\t *\n\t *  @dtopt Options\n\t *  @name DataTable.defaults.dom\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"dom\": '&lt;\"top\"i&gt;rt&lt;\"bottom\"flp&gt;&lt;\"clear\"&gt;'\n\t *      } );\n\t *    } );\n\t */\n\t\"sDom\": \"lfrtip\",\n\n\n\t/**\n\t * Search delay option. This will throttle full table searches that use the\n\t * DataTables provided search input element (it does not effect calls to\n\t * `dt-api search()`, providing a delay before the search is made.\n\t *  @type integer\n\t *  @default 0\n\t *\n\t *  @dtopt Options\n\t *  @name DataTable.defaults.searchDelay\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"searchDelay\": 200\n\t *      } );\n\t *    } )\n\t */\n\t\"searchDelay\": null,\n\n\n\t/**\n\t * DataTables features six different built-in options for the buttons to\n\t * display for pagination control:\n\t *\n\t * * `numbers` - Page number buttons only\n\t * * `simple` - 'Previous' and 'Next' buttons only\n\t * * 'simple_numbers` - 'Previous' and 'Next' buttons, plus page numbers\n\t * * `full` - 'First', 'Previous', 'Next' and 'Last' buttons\n\t * * `full_numbers` - 'First', 'Previous', 'Next' and 'Last' buttons, plus page numbers\n\t * * `first_last_numbers` - 'First' and 'Last' buttons, plus page numbers\n\t *  \n\t * Further methods can be added using {@link DataTable.ext.oPagination}.\n\t *  @type string\n\t *  @default simple_numbers\n\t *\n\t *  @dtopt Options\n\t *  @name DataTable.defaults.pagingType\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"pagingType\": \"full_numbers\"\n\t *      } );\n\t *    } )\n\t */\n\t\"sPaginationType\": \"simple_numbers\",\n\n\n\t/**\n\t * Enable horizontal scrolling. When a table is too wide to fit into a\n\t * certain layout, or you have a large number of columns in the table, you\n\t * can enable x-scrolling to show the table in a viewport, which can be\n\t * scrolled. This property can be `true` which will allow the table to\n\t * scroll horizontally when needed, or any CSS unit, or a number (in which\n\t * case it will be treated as a pixel measurement). Setting as simply `true`\n\t * is recommended.\n\t *  @type boolean|string\n\t *  @default <i>blank string - i.e. disabled</i>\n\t *\n\t *  @dtopt Features\n\t *  @name DataTable.defaults.scrollX\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"scrollX\": true,\n\t *        \"scrollCollapse\": true\n\t *      } );\n\t *    } );\n\t */\n\t\"sScrollX\": \"\",\n\n\n\t/**\n\t * This property can be used to force a DataTable to use more width than it\n\t * might otherwise do when x-scrolling is enabled. For example if you have a\n\t * table which requires to be well spaced, this parameter is useful for\n\t * \"over-sizing\" the table, and thus forcing scrolling. This property can by\n\t * any CSS unit, or a number (in which case it will be treated as a pixel\n\t * measurement).\n\t *  @type string\n\t *  @default <i>blank string - i.e. disabled</i>\n\t *\n\t *  @dtopt Options\n\t *  @name DataTable.defaults.scrollXInner\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"scrollX\": \"100%\",\n\t *        \"scrollXInner\": \"110%\"\n\t *      } );\n\t *    } );\n\t */\n\t\"sScrollXInner\": \"\",\n\n\n\t/**\n\t * Enable vertical scrolling. Vertical scrolling will constrain the DataTable\n\t * to the given height, and enable scrolling for any data which overflows the\n\t * current viewport. This can be used as an alternative to paging to display\n\t * a lot of data in a small area (although paging and scrolling can both be\n\t * enabled at the same time). This property can be any CSS unit, or a number\n\t * (in which case it will be treated as a pixel measurement).\n\t *  @type string\n\t *  @default <i>blank string - i.e. disabled</i>\n\t *\n\t *  @dtopt Features\n\t *  @name DataTable.defaults.scrollY\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"scrollY\": \"200px\",\n\t *        \"paginate\": false\n\t *      } );\n\t *    } );\n\t */\n\t\"sScrollY\": \"\",\n\n\n\t/**\n\t * __Deprecated__ The functionality provided by this parameter has now been\n\t * superseded by that provided through `ajax`, which should be used instead.\n\t *\n\t * Set the HTTP method that is used to make the Ajax call for server-side\n\t * processing or Ajax sourced data.\n\t *  @type string\n\t *  @default GET\n\t *\n\t *  @dtopt Options\n\t *  @dtopt Server-side\n\t *  @name DataTable.defaults.serverMethod\n\t *\n\t *  @deprecated 1.10. Please use `ajax` for this functionality now.\n\t */\n\t\"sServerMethod\": \"GET\",\n\n\n\t/**\n\t * DataTables makes use of renderers when displaying HTML elements for\n\t * a table. These renderers can be added or modified by plug-ins to\n\t * generate suitable mark-up for a site. For example the Bootstrap\n\t * integration plug-in for DataTables uses a paging button renderer to\n\t * display pagination buttons in the mark-up required by Bootstrap.\n\t *\n\t * For further information about the renderers available see\n\t * DataTable.ext.renderer\n\t *  @type string|object\n\t *  @default null\n\t *\n\t *  @name DataTable.defaults.renderer\n\t *\n\t */\n\t\"renderer\": null,\n\n\n\t/**\n\t * Set the data property name that DataTables should use to get a row's id\n\t * to set as the `id` property in the node.\n\t *  @type string\n\t *  @default DT_RowId\n\t *\n\t *  @name DataTable.defaults.rowId\n\t */\n\t\"rowId\": \"DT_RowId\"\n};\n\n_fnHungarianMap( DataTable.defaults );\n\n\n\n/*\n * Developer note - See note in model.defaults.js about the use of Hungarian\n * notation and camel case.\n */\n\n/**\n * Column options that can be given to DataTables at initialisation time.\n *  @namespace\n */\nDataTable.defaults.column = {\n\t/**\n\t * Define which column(s) an order will occur on for this column. This\n\t * allows a column's ordering to take multiple columns into account when\n\t * doing a sort or use the data from a different column. For example first\n\t * name / last name columns make sense to do a multi-column sort over the\n\t * two columns.\n\t *  @type array|int\n\t *  @default null <i>Takes the value of the column index automatically</i>\n\t *\n\t *  @name DataTable.defaults.column.orderData\n\t *  @dtopt Columns\n\t *\n\t *  @example\n\t *    // Using `columnDefs`\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columnDefs\": [\n\t *          { \"orderData\": [ 0, 1 ], \"targets\": [ 0 ] },\n\t *          { \"orderData\": [ 1, 0 ], \"targets\": [ 1 ] },\n\t *          { \"orderData\": 2, \"targets\": [ 2 ] }\n\t *        ]\n\t *      } );\n\t *    } );\n\t *\n\t *  @example\n\t *    // Using `columns`\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columns\": [\n\t *          { \"orderData\": [ 0, 1 ] },\n\t *          { \"orderData\": [ 1, 0 ] },\n\t *          { \"orderData\": 2 },\n\t *          null,\n\t *          null\n\t *        ]\n\t *      } );\n\t *    } );\n\t */\n\t\"aDataSort\": null,\n\t\"iDataSort\": -1,\n\n\n\t/**\n\t * You can control the default ordering direction, and even alter the\n\t * behaviour of the sort handler (i.e. only allow ascending ordering etc)\n\t * using this parameter.\n\t *  @type array\n\t *  @default [ 'asc', 'desc' ]\n\t *\n\t *  @name DataTable.defaults.column.orderSequence\n\t *  @dtopt Columns\n\t *\n\t *  @example\n\t *    // Using `columnDefs`\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columnDefs\": [\n\t *          { \"orderSequence\": [ \"asc\" ], \"targets\": [ 1 ] },\n\t *          { \"orderSequence\": [ \"desc\", \"asc\", \"asc\" ], \"targets\": [ 2 ] },\n\t *          { \"orderSequence\": [ \"desc\" ], \"targets\": [ 3 ] }\n\t *        ]\n\t *      } );\n\t *    } );\n\t *\n\t *  @example\n\t *    // Using `columns`\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columns\": [\n\t *          null,\n\t *          { \"orderSequence\": [ \"asc\" ] },\n\t *          { \"orderSequence\": [ \"desc\", \"asc\", \"asc\" ] },\n\t *          { \"orderSequence\": [ \"desc\" ] },\n\t *          null\n\t *        ]\n\t *      } );\n\t *    } );\n\t */\n\t\"asSorting\": [ 'asc', 'desc' ],\n\n\n\t/**\n\t * Enable or disable filtering on the data in this column.\n\t *  @type boolean\n\t *  @default true\n\t *\n\t *  @name DataTable.defaults.column.searchable\n\t *  @dtopt Columns\n\t *\n\t *  @example\n\t *    // Using `columnDefs`\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columnDefs\": [\n\t *          { \"searchable\": false, \"targets\": [ 0 ] }\n\t *        ] } );\n\t *    } );\n\t *\n\t *  @example\n\t *    // Using `columns`\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columns\": [\n\t *          { \"searchable\": false },\n\t *          null,\n\t *          null,\n\t *          null,\n\t *          null\n\t *        ] } );\n\t *    } );\n\t */\n\t\"bSearchable\": true,\n\n\n\t/**\n\t * Enable or disable ordering on this column.\n\t *  @type boolean\n\t *  @default true\n\t *\n\t *  @name DataTable.defaults.column.orderable\n\t *  @dtopt Columns\n\t *\n\t *  @example\n\t *    // Using `columnDefs`\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columnDefs\": [\n\t *          { \"orderable\": false, \"targets\": [ 0 ] }\n\t *        ] } );\n\t *    } );\n\t *\n\t *  @example\n\t *    // Using `columns`\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columns\": [\n\t *          { \"orderable\": false },\n\t *          null,\n\t *          null,\n\t *          null,\n\t *          null\n\t *        ] } );\n\t *    } );\n\t */\n\t\"bSortable\": true,\n\n\n\t/**\n\t * Enable or disable the display of this column.\n\t *  @type boolean\n\t *  @default true\n\t *\n\t *  @name DataTable.defaults.column.visible\n\t *  @dtopt Columns\n\t *\n\t *  @example\n\t *    // Using `columnDefs`\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columnDefs\": [\n\t *          { \"visible\": false, \"targets\": [ 0 ] }\n\t *        ] } );\n\t *    } );\n\t *\n\t *  @example\n\t *    // Using `columns`\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columns\": [\n\t *          { \"visible\": false },\n\t *          null,\n\t *          null,\n\t *          null,\n\t *          null\n\t *        ] } );\n\t *    } );\n\t */\n\t\"bVisible\": true,\n\n\n\t/**\n\t * Developer definable function that is called whenever a cell is created (Ajax source,\n\t * etc) or processed for input (DOM source). This can be used as a compliment to mRender\n\t * allowing you to modify the DOM element (add background colour for example) when the\n\t * element is available.\n\t *  @type function\n\t *  @param {element} td The TD node that has been created\n\t *  @param {*} cellData The Data for the cell\n\t *  @param {array|object} rowData The data for the whole row\n\t *  @param {int} row The row index for the aoData data store\n\t *  @param {int} col The column index for aoColumns\n\t *\n\t *  @name DataTable.defaults.column.createdCell\n\t *  @dtopt Columns\n\t *\n\t *  @example\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columnDefs\": [ {\n\t *          \"targets\": [3],\n\t *          \"createdCell\": function (td, cellData, rowData, row, col) {\n\t *            if ( cellData == \"1.7\" ) {\n\t *              $(td).css('color', 'blue')\n\t *            }\n\t *          }\n\t *        } ]\n\t *      });\n\t *    } );\n\t */\n\t\"fnCreatedCell\": null,\n\n\n\t/**\n\t * This parameter has been replaced by `data` in DataTables to ensure naming\n\t * consistency. `dataProp` can still be used, as there is backwards\n\t * compatibility in DataTables for this option, but it is strongly\n\t * recommended that you use `data` in preference to `dataProp`.\n\t *  @name DataTable.defaults.column.dataProp\n\t */\n\n\n\t/**\n\t * This property can be used to read data from any data source property,\n\t * including deeply nested objects / properties. `data` can be given in a\n\t * number of different ways which effect its behaviour:\n\t *\n\t * * `integer` - treated as an array index for the data source. This is the\n\t *   default that DataTables uses (incrementally increased for each column).\n\t * * `string` - read an object property from the data source. There are\n\t *   three 'special' options that can be used in the string to alter how\n\t *   DataTables reads the data from the source object:\n\t *    * `.` - Dotted Javascript notation. Just as you use a `.` in\n\t *      Javascript to read from nested objects, so to can the options\n\t *      specified in `data`. For example: `browser.version` or\n\t *      `browser.name`. If your object parameter name contains a period, use\n\t *      `\\\\` to escape it - i.e. `first\\\\.name`.\n\t *    * `[]` - Array notation. DataTables can automatically combine data\n\t *      from and array source, joining the data with the characters provided\n\t *      between the two brackets. For example: `name[, ]` would provide a\n\t *      comma-space separated list from the source array. If no characters\n\t *      are provided between the brackets, the original array source is\n\t *      returned.\n\t *    * `()` - Function notation. Adding `()` to the end of a parameter will\n\t *      execute a function of the name given. For example: `browser()` for a\n\t *      simple function on the data source, `browser.version()` for a\n\t *      function in a nested property or even `browser().version` to get an\n\t *      object property if the function called returns an object. Note that\n\t *      function notation is recommended for use in `render` rather than\n\t *      `data` as it is much simpler to use as a renderer.\n\t * * `null` - use the original data source for the row rather than plucking\n\t *   data directly from it. This action has effects on two other\n\t *   initialisation options:\n\t *    * `defaultContent` - When null is given as the `data` option and\n\t *      `defaultContent` is specified for the column, the value defined by\n\t *      `defaultContent` will be used for the cell.\n\t *    * `render` - When null is used for the `data` option and the `render`\n\t *      option is specified for the column, the whole data source for the\n\t *      row is used for the renderer.\n\t * * `function` - the function given will be executed whenever DataTables\n\t *   needs to set or get the data for a cell in the column. The function\n\t *   takes three parameters:\n\t *    * Parameters:\n\t *      * `{array|object}` The data source for the row\n\t *      * `{string}` The type call data requested - this will be 'set' when\n\t *        setting data or 'filter', 'display', 'type', 'sort' or undefined\n\t *        when gathering data. Note that when `undefined` is given for the\n\t *        type DataTables expects to get the raw data for the object back<\n\t *      * `{*}` Data to set when the second parameter is 'set'.\n\t *    * Return:\n\t *      * The return value from the function is not required when 'set' is\n\t *        the type of call, but otherwise the return is what will be used\n\t *        for the data requested.\n\t *\n\t * Note that `data` is a getter and setter option. If you just require\n\t * formatting of data for output, you will likely want to use `render` which\n\t * is simply a getter and thus simpler to use.\n\t *\n\t * Note that prior to DataTables 1.9.2 `data` was called `mDataProp`. The\n\t * name change reflects the flexibility of this property and is consistent\n\t * with the naming of mRender. If 'mDataProp' is given, then it will still\n\t * be used by DataTables, as it automatically maps the old name to the new\n\t * if required.\n\t *\n\t *  @type string|int|function|null\n\t *  @default null <i>Use automatically calculated column index</i>\n\t *\n\t *  @name DataTable.defaults.column.data\n\t *  @dtopt Columns\n\t *\n\t *  @example\n\t *    // Read table data from objects\n\t *    // JSON structure for each row:\n\t *    //   {\n\t *    //      \"engine\": {value},\n\t *    //      \"browser\": {value},\n\t *    //      \"platform\": {value},\n\t *    //      \"version\": {value},\n\t *    //      \"grade\": {value}\n\t *    //   }\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"ajaxSource\": \"sources/objects.txt\",\n\t *        \"columns\": [\n\t *          { \"data\": \"engine\" },\n\t *          { \"data\": \"browser\" },\n\t *          { \"data\": \"platform\" },\n\t *          { \"data\": \"version\" },\n\t *          { \"data\": \"grade\" }\n\t *        ]\n\t *      } );\n\t *    } );\n\t *\n\t *  @example\n\t *    // Read information from deeply nested objects\n\t *    // JSON structure for each row:\n\t *    //   {\n\t *    //      \"engine\": {value},\n\t *    //      \"browser\": {value},\n\t *    //      \"platform\": {\n\t *    //         \"inner\": {value}\n\t *    //      },\n\t *    //      \"details\": [\n\t *    //         {value}, {value}\n\t *    //      ]\n\t *    //   }\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"ajaxSource\": \"sources/deep.txt\",\n\t *        \"columns\": [\n\t *          { \"data\": \"engine\" },\n\t *          { \"data\": \"browser\" },\n\t *          { \"data\": \"platform.inner\" },\n\t *          { \"data\": \"details.0\" },\n\t *          { \"data\": \"details.1\" }\n\t *        ]\n\t *      } );\n\t *    } );\n\t *\n\t *  @example\n\t *    // Using `data` as a function to provide different information for\n\t *    // sorting, filtering and display. In this case, currency (price)\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columnDefs\": [ {\n\t *          \"targets\": [ 0 ],\n\t *          \"data\": function ( source, type, val ) {\n\t *            if (type === 'set') {\n\t *              source.price = val;\n\t *              // Store the computed display and filter values for efficiency\n\t *              source.price_display = val==\"\" ? \"\" : \"$\"+numberFormat(val);\n\t *              source.price_filter  = val==\"\" ? \"\" : \"$\"+numberFormat(val)+\" \"+val;\n\t *              return;\n\t *            }\n\t *            else if (type === 'display') {\n\t *              return source.price_display;\n\t *            }\n\t *            else if (type === 'filter') {\n\t *              return source.price_filter;\n\t *            }\n\t *            // 'sort', 'type' and undefined all just use the integer\n\t *            return source.price;\n\t *          }\n\t *        } ]\n\t *      } );\n\t *    } );\n\t *\n\t *  @example\n\t *    // Using default content\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columnDefs\": [ {\n\t *          \"targets\": [ 0 ],\n\t *          \"data\": null,\n\t *          \"defaultContent\": \"Click to edit\"\n\t *        } ]\n\t *      } );\n\t *    } );\n\t *\n\t *  @example\n\t *    // Using array notation - outputting a list from an array\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columnDefs\": [ {\n\t *          \"targets\": [ 0 ],\n\t *          \"data\": \"name[, ]\"\n\t *        } ]\n\t *      } );\n\t *    } );\n\t *\n\t */\n\t\"mData\": null,\n\n\n\t/**\n\t * This property is the rendering partner to `data` and it is suggested that\n\t * when you want to manipulate data for display (including filtering,\n\t * sorting etc) without altering the underlying data for the table, use this\n\t * property. `render` can be considered to be the the read only companion to\n\t * `data` which is read / write (then as such more complex). Like `data`\n\t * this option can be given in a number of different ways to effect its\n\t * behaviour:\n\t *\n\t * * `integer` - treated as an array index for the data source. This is the\n\t *   default that DataTables uses (incrementally increased for each column).\n\t * * `string` - read an object property from the data source. There are\n\t *   three 'special' options that can be used in the string to alter how\n\t *   DataTables reads the data from the source object:\n\t *    * `.` - Dotted Javascript notation. Just as you use a `.` in\n\t *      Javascript to read from nested objects, so to can the options\n\t *      specified in `data`. For example: `browser.version` or\n\t *      `browser.name`. If your object parameter name contains a period, use\n\t *      `\\\\` to escape it - i.e. `first\\\\.name`.\n\t *    * `[]` - Array notation. DataTables can automatically combine data\n\t *      from and array source, joining the data with the characters provided\n\t *      between the two brackets. For example: `name[, ]` would provide a\n\t *      comma-space separated list from the source array. If no characters\n\t *      are provided between the brackets, the original array source is\n\t *      returned.\n\t *    * `()` - Function notation. Adding `()` to the end of a parameter will\n\t *      execute a function of the name given. For example: `browser()` for a\n\t *      simple function on the data source, `browser.version()` for a\n\t *      function in a nested property or even `browser().version` to get an\n\t *      object property if the function called returns an object.\n\t * * `object` - use different data for the different data types requested by\n\t *   DataTables ('filter', 'display', 'type' or 'sort'). The property names\n\t *   of the object is the data type the property refers to and the value can\n\t *   defined using an integer, string or function using the same rules as\n\t *   `render` normally does. Note that an `_` option _must_ be specified.\n\t *   This is the default value to use if you haven't specified a value for\n\t *   the data type requested by DataTables.\n\t * * `function` - the function given will be executed whenever DataTables\n\t *   needs to set or get the data for a cell in the column. The function\n\t *   takes three parameters:\n\t *    * Parameters:\n\t *      * {array|object} The data source for the row (based on `data`)\n\t *      * {string} The type call data requested - this will be 'filter',\n\t *        'display', 'type' or 'sort'.\n\t *      * {array|object} The full data source for the row (not based on\n\t *        `data`)\n\t *    * Return:\n\t *      * The return value from the function is what will be used for the\n\t *        data requested.\n\t *\n\t *  @type string|int|function|object|null\n\t *  @default null Use the data source value.\n\t *\n\t *  @name DataTable.defaults.column.render\n\t *  @dtopt Columns\n\t *\n\t *  @example\n\t *    // Create a comma separated list from an array of objects\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"ajaxSource\": \"sources/deep.txt\",\n\t *        \"columns\": [\n\t *          { \"data\": \"engine\" },\n\t *          { \"data\": \"browser\" },\n\t *          {\n\t *            \"data\": \"platform\",\n\t *            \"render\": \"[, ].name\"\n\t *          }\n\t *        ]\n\t *      } );\n\t *    } );\n\t *\n\t *  @example\n\t *    // Execute a function to obtain data\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columnDefs\": [ {\n\t *          \"targets\": [ 0 ],\n\t *          \"data\": null, // Use the full data source object for the renderer's source\n\t *          \"render\": \"browserName()\"\n\t *        } ]\n\t *      } );\n\t *    } );\n\t *\n\t *  @example\n\t *    // As an object, extracting different data for the different types\n\t *    // This would be used with a data source such as:\n\t *    //   { \"phone\": 5552368, \"phone_filter\": \"5552368 555-2368\", \"phone_display\": \"555-2368\" }\n\t *    // Here the `phone` integer is used for sorting and type detection, while `phone_filter`\n\t *    // (which has both forms) is used for filtering for if a user inputs either format, while\n\t *    // the formatted phone number is the one that is shown in the table.\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columnDefs\": [ {\n\t *          \"targets\": [ 0 ],\n\t *          \"data\": null, // Use the full data source object for the renderer's source\n\t *          \"render\": {\n\t *            \"_\": \"phone\",\n\t *            \"filter\": \"phone_filter\",\n\t *            \"display\": \"phone_display\"\n\t *          }\n\t *        } ]\n\t *      } );\n\t *    } );\n\t *\n\t *  @example\n\t *    // Use as a function to create a link from the data source\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columnDefs\": [ {\n\t *          \"targets\": [ 0 ],\n\t *          \"data\": \"download_link\",\n\t *          \"render\": function ( data, type, full ) {\n\t *            return '<a href=\"'+data+'\">Download</a>';\n\t *          }\n\t *        } ]\n\t *      } );\n\t *    } );\n\t */\n\t\"mRender\": null,\n\n\n\t/**\n\t * Change the cell type created for the column - either TD cells or TH cells. This\n\t * can be useful as TH cells have semantic meaning in the table body, allowing them\n\t * to act as a header for a row (you may wish to add scope='row' to the TH elements).\n\t *  @type string\n\t *  @default td\n\t *\n\t *  @name DataTable.defaults.column.cellType\n\t *  @dtopt Columns\n\t *\n\t *  @example\n\t *    // Make the first column use TH cells\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columnDefs\": [ {\n\t *          \"targets\": [ 0 ],\n\t *          \"cellType\": \"th\"\n\t *        } ]\n\t *      } );\n\t *    } );\n\t */\n\t\"sCellType\": \"td\",\n\n\n\t/**\n\t * Class to give to each cell in this column.\n\t *  @type string\n\t *  @default <i>Empty string</i>\n\t *\n\t *  @name DataTable.defaults.column.class\n\t *  @dtopt Columns\n\t *\n\t *  @example\n\t *    // Using `columnDefs`\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columnDefs\": [\n\t *          { \"class\": \"my_class\", \"targets\": [ 0 ] }\n\t *        ]\n\t *      } );\n\t *    } );\n\t *\n\t *  @example\n\t *    // Using `columns`\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columns\": [\n\t *          { \"class\": \"my_class\" },\n\t *          null,\n\t *          null,\n\t *          null,\n\t *          null\n\t *        ]\n\t *      } );\n\t *    } );\n\t */\n\t\"sClass\": \"\",\n\n\t/**\n\t * When DataTables calculates the column widths to assign to each column,\n\t * it finds the longest string in each column and then constructs a\n\t * temporary table and reads the widths from that. The problem with this\n\t * is that \"mmm\" is much wider then \"iiii\", but the latter is a longer\n\t * string - thus the calculation can go wrong (doing it properly and putting\n\t * it into an DOM object and measuring that is horribly(!) slow). Thus as\n\t * a \"work around\" we provide this option. It will append its value to the\n\t * text that is found to be the longest string for the column - i.e. padding.\n\t * Generally you shouldn't need this!\n\t *  @type string\n\t *  @default <i>Empty string<i>\n\t *\n\t *  @name DataTable.defaults.column.contentPadding\n\t *  @dtopt Columns\n\t *\n\t *  @example\n\t *    // Using `columns`\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columns\": [\n\t *          null,\n\t *          null,\n\t *          null,\n\t *          {\n\t *            \"contentPadding\": \"mmm\"\n\t *          }\n\t *        ]\n\t *      } );\n\t *    } );\n\t */\n\t\"sContentPadding\": \"\",\n\n\n\t/**\n\t * Allows a default value to be given for a column's data, and will be used\n\t * whenever a null data source is encountered (this can be because `data`\n\t * is set to null, or because the data source itself is null).\n\t *  @type string\n\t *  @default null\n\t *\n\t *  @name DataTable.defaults.column.defaultContent\n\t *  @dtopt Columns\n\t *\n\t *  @example\n\t *    // Using `columnDefs`\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columnDefs\": [\n\t *          {\n\t *            \"data\": null,\n\t *            \"defaultContent\": \"Edit\",\n\t *            \"targets\": [ -1 ]\n\t *          }\n\t *        ]\n\t *      } );\n\t *    } );\n\t *\n\t *  @example\n\t *    // Using `columns`\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columns\": [\n\t *          null,\n\t *          null,\n\t *          null,\n\t *          {\n\t *            \"data\": null,\n\t *            \"defaultContent\": \"Edit\"\n\t *          }\n\t *        ]\n\t *      } );\n\t *    } );\n\t */\n\t\"sDefaultContent\": null,\n\n\n\t/**\n\t * This parameter is only used in DataTables' server-side processing. It can\n\t * be exceptionally useful to know what columns are being displayed on the\n\t * client side, and to map these to database fields. When defined, the names\n\t * also allow DataTables to reorder information from the server if it comes\n\t * back in an unexpected order (i.e. if you switch your columns around on the\n\t * client-side, your server-side code does not also need updating).\n\t *  @type string\n\t *  @default <i>Empty string</i>\n\t *\n\t *  @name DataTable.defaults.column.name\n\t *  @dtopt Columns\n\t *\n\t *  @example\n\t *    // Using `columnDefs`\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columnDefs\": [\n\t *          { \"name\": \"engine\", \"targets\": [ 0 ] },\n\t *          { \"name\": \"browser\", \"targets\": [ 1 ] },\n\t *          { \"name\": \"platform\", \"targets\": [ 2 ] },\n\t *          { \"name\": \"version\", \"targets\": [ 3 ] },\n\t *          { \"name\": \"grade\", \"targets\": [ 4 ] }\n\t *        ]\n\t *      } );\n\t *    } );\n\t *\n\t *  @example\n\t *    // Using `columns`\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columns\": [\n\t *          { \"name\": \"engine\" },\n\t *          { \"name\": \"browser\" },\n\t *          { \"name\": \"platform\" },\n\t *          { \"name\": \"version\" },\n\t *          { \"name\": \"grade\" }\n\t *        ]\n\t *      } );\n\t *    } );\n\t */\n\t\"sName\": \"\",\n\n\n\t/**\n\t * Defines a data source type for the ordering which can be used to read\n\t * real-time information from the table (updating the internally cached\n\t * version) prior to ordering. This allows ordering to occur on user\n\t * editable elements such as form inputs.\n\t *  @type string\n\t *  @default std\n\t *\n\t *  @name DataTable.defaults.column.orderDataType\n\t *  @dtopt Columns\n\t *\n\t *  @example\n\t *    // Using `columnDefs`\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columnDefs\": [\n\t *          { \"orderDataType\": \"dom-text\", \"targets\": [ 2, 3 ] },\n\t *          { \"type\": \"numeric\", \"targets\": [ 3 ] },\n\t *          { \"orderDataType\": \"dom-select\", \"targets\": [ 4 ] },\n\t *          { \"orderDataType\": \"dom-checkbox\", \"targets\": [ 5 ] }\n\t *        ]\n\t *      } );\n\t *    } );\n\t *\n\t *  @example\n\t *    // Using `columns`\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columns\": [\n\t *          null,\n\t *          null,\n\t *          { \"orderDataType\": \"dom-text\" },\n\t *          { \"orderDataType\": \"dom-text\", \"type\": \"numeric\" },\n\t *          { \"orderDataType\": \"dom-select\" },\n\t *          { \"orderDataType\": \"dom-checkbox\" }\n\t *        ]\n\t *      } );\n\t *    } );\n\t */\n\t\"sSortDataType\": \"std\",\n\n\n\t/**\n\t * The title of this column.\n\t *  @type string\n\t *  @default null <i>Derived from the 'TH' value for this column in the\n\t *    original HTML table.</i>\n\t *\n\t *  @name DataTable.defaults.column.title\n\t *  @dtopt Columns\n\t *\n\t *  @example\n\t *    // Using `columnDefs`\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columnDefs\": [\n\t *          { \"title\": \"My column title\", \"targets\": [ 0 ] }\n\t *        ]\n\t *      } );\n\t *    } );\n\t *\n\t *  @example\n\t *    // Using `columns`\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columns\": [\n\t *          { \"title\": \"My column title\" },\n\t *          null,\n\t *          null,\n\t *          null,\n\t *          null\n\t *        ]\n\t *      } );\n\t *    } );\n\t */\n\t\"sTitle\": null,\n\n\n\t/**\n\t * The type allows you to specify how the data for this column will be\n\t * ordered. Four types (string, numeric, date and html (which will strip\n\t * HTML tags before ordering)) are currently available. Note that only date\n\t * formats understood by Javascript's Date() object will be accepted as type\n\t * date. For example: \"Mar 26, 2008 5:03 PM\". May take the values: 'string',\n\t * 'numeric', 'date' or 'html' (by default). Further types can be adding\n\t * through plug-ins.\n\t *  @type string\n\t *  @default null <i>Auto-detected from raw data</i>\n\t *\n\t *  @name DataTable.defaults.column.type\n\t *  @dtopt Columns\n\t *\n\t *  @example\n\t *    // Using `columnDefs`\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columnDefs\": [\n\t *          { \"type\": \"html\", \"targets\": [ 0 ] }\n\t *        ]\n\t *      } );\n\t *    } );\n\t *\n\t *  @example\n\t *    // Using `columns`\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columns\": [\n\t *          { \"type\": \"html\" },\n\t *          null,\n\t *          null,\n\t *          null,\n\t *          null\n\t *        ]\n\t *      } );\n\t *    } );\n\t */\n\t\"sType\": null,\n\n\n\t/**\n\t * Defining the width of the column, this parameter may take any CSS value\n\t * (3em, 20px etc). DataTables applies 'smart' widths to columns which have not\n\t * been given a specific width through this interface ensuring that the table\n\t * remains readable.\n\t *  @type string\n\t *  @default null <i>Automatic</i>\n\t *\n\t *  @name DataTable.defaults.column.width\n\t *  @dtopt Columns\n\t *\n\t *  @example\n\t *    // Using `columnDefs`\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columnDefs\": [\n\t *          { \"width\": \"20%\", \"targets\": [ 0 ] }\n\t *        ]\n\t *      } );\n\t *    } );\n\t *\n\t *  @example\n\t *    // Using `columns`\n\t *    $(document).ready( function() {\n\t *      $('#example').dataTable( {\n\t *        \"columns\": [\n\t *          { \"width\": \"20%\" },\n\t *          null,\n\t *          null,\n\t *          null,\n\t *          null\n\t *        ]\n\t *      } );\n\t *    } );\n\t */\n\t\"sWidth\": null\n};\n\n_fnHungarianMap( DataTable.defaults.column );\n\n\n\n/**\n * DataTables settings object - this holds all the information needed for a\n * given table, including configuration, data and current application of the\n * table options. DataTables does not have a single instance for each DataTable\n * with the settings attached to that instance, but rather instances of the\n * DataTable \"class\" are created on-the-fly as needed (typically by a\n * $().dataTable() call) and the settings object is then applied to that\n * instance.\n *\n * Note that this object is related to {@link DataTable.defaults} but this\n * one is the internal data store for DataTables's cache of columns. It should\n * NOT be manipulated outside of DataTables. Any configuration should be done\n * through the initialisation options.\n *  @namespace\n *  @todo Really should attach the settings object to individual instances so we\n *    don't need to create new instances on each $().dataTable() call (if the\n *    table already exists). It would also save passing oSettings around and\n *    into every single function. However, this is a very significant\n *    architecture change for DataTables and will almost certainly break\n *    backwards compatibility with older installations. This is something that\n *    will be done in 2.0.\n */\nDataTable.models.oSettings = {\n\t/**\n\t * Primary features of DataTables and their enablement state.\n\t *  @namespace\n\t */\n\t\"oFeatures\": {\n\n\t\t/**\n\t\t * Flag to say if DataTables should automatically try to calculate the\n\t\t * optimum table and columns widths (true) or not (false).\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\"bAutoWidth\": null,\n\n\t\t/**\n\t\t * Delay the creation of TR and TD elements until they are actually\n\t\t * needed by a driven page draw. This can give a significant speed\n\t\t * increase for Ajax source and Javascript source data, but makes no\n\t\t * difference at all for DOM and server-side processing tables.\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\"bDeferRender\": null,\n\n\t\t/**\n\t\t * Enable filtering on the table or not. Note that if this is disabled\n\t\t * then there is no filtering at all on the table, including fnFilter.\n\t\t * To just remove the filtering input use sDom and remove the 'f' option.\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\"bFilter\": null,\n\n\t\t/**\n\t\t * Table information element (the 'Showing x of y records' div) enable\n\t\t * flag.\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\"bInfo\": null,\n\n\t\t/**\n\t\t * Present a user control allowing the end user to change the page size\n\t\t * when pagination is enabled.\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\"bLengthChange\": null,\n\n\t\t/**\n\t\t * Pagination enabled or not. Note that if this is disabled then length\n\t\t * changing must also be disabled.\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\"bPaginate\": null,\n\n\t\t/**\n\t\t * Processing indicator enable flag whenever DataTables is enacting a\n\t\t * user request - typically an Ajax request for server-side processing.\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\"bProcessing\": null,\n\n\t\t/**\n\t\t * Server-side processing enabled flag - when enabled DataTables will\n\t\t * get all data from the server for every draw - there is no filtering,\n\t\t * sorting or paging done on the client-side.\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\"bServerSide\": null,\n\n\t\t/**\n\t\t * Sorting enablement flag.\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\"bSort\": null,\n\n\t\t/**\n\t\t * Multi-column sorting\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\"bSortMulti\": null,\n\n\t\t/**\n\t\t * Apply a class to the columns which are being sorted to provide a\n\t\t * visual highlight or not. This can slow things down when enabled since\n\t\t * there is a lot of DOM interaction.\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\"bSortClasses\": null,\n\n\t\t/**\n\t\t * State saving enablement flag.\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\"bStateSave\": null\n\t},\n\n\n\t/**\n\t * Scrolling settings for a table.\n\t *  @namespace\n\t */\n\t\"oScroll\": {\n\t\t/**\n\t\t * When the table is shorter in height than sScrollY, collapse the\n\t\t * table container down to the height of the table (when true).\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\"bCollapse\": null,\n\n\t\t/**\n\t\t * Width of the scrollbar for the web-browser's platform. Calculated\n\t\t * during table initialisation.\n\t\t *  @type int\n\t\t *  @default 0\n\t\t */\n\t\t\"iBarWidth\": 0,\n\n\t\t/**\n\t\t * Viewport width for horizontal scrolling. Horizontal scrolling is\n\t\t * disabled if an empty string.\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\"sX\": null,\n\n\t\t/**\n\t\t * Width to expand the table to when using x-scrolling. Typically you\n\t\t * should not need to use this.\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 *  @deprecated\n\t\t */\n\t\t\"sXInner\": null,\n\n\t\t/**\n\t\t * Viewport height for vertical scrolling. Vertical scrolling is disabled\n\t\t * if an empty string.\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\"sY\": null\n\t},\n\n\t/**\n\t * Language information for the table.\n\t *  @namespace\n\t *  @extends DataTable.defaults.oLanguage\n\t */\n\t\"oLanguage\": {\n\t\t/**\n\t\t * Information callback function. See\n\t\t * {@link DataTable.defaults.fnInfoCallback}\n\t\t *  @type function\n\t\t *  @default null\n\t\t */\n\t\t\"fnInfoCallback\": null\n\t},\n\n\t/**\n\t * Browser support parameters\n\t *  @namespace\n\t */\n\t\"oBrowser\": {\n\t\t/**\n\t\t * Indicate if the browser incorrectly calculates width:100% inside a\n\t\t * scrolling element (IE6/7)\n\t\t *  @type boolean\n\t\t *  @default false\n\t\t */\n\t\t\"bScrollOversize\": false,\n\n\t\t/**\n\t\t * Determine if the vertical scrollbar is on the right or left of the\n\t\t * scrolling container - needed for rtl language layout, although not\n\t\t * all browsers move the scrollbar (Safari).\n\t\t *  @type boolean\n\t\t *  @default false\n\t\t */\n\t\t\"bScrollbarLeft\": false,\n\n\t\t/**\n\t\t * Flag for if `getBoundingClientRect` is fully supported or not\n\t\t *  @type boolean\n\t\t *  @default false\n\t\t */\n\t\t\"bBounding\": false,\n\n\t\t/**\n\t\t * Browser scrollbar width\n\t\t *  @type integer\n\t\t *  @default 0\n\t\t */\n\t\t\"barWidth\": 0\n\t},\n\n\n\t\"ajax\": null,\n\n\n\t/**\n\t * Array referencing the nodes which are used for the features. The\n\t * parameters of this object match what is allowed by sDom - i.e.\n\t *   <ul>\n\t *     <li>'l' - Length changing</li>\n\t *     <li>'f' - Filtering input</li>\n\t *     <li>'t' - The table!</li>\n\t *     <li>'i' - Information</li>\n\t *     <li>'p' - Pagination</li>\n\t *     <li>'r' - pRocessing</li>\n\t *   </ul>\n\t *  @type array\n\t *  @default []\n\t */\n\t\"aanFeatures\": [],\n\n\t/**\n\t * Store data information - see {@link DataTable.models.oRow} for detailed\n\t * information.\n\t *  @type array\n\t *  @default []\n\t */\n\t\"aoData\": [],\n\n\t/**\n\t * Array of indexes which are in the current display (after filtering etc)\n\t *  @type array\n\t *  @default []\n\t */\n\t\"aiDisplay\": [],\n\n\t/**\n\t * Array of indexes for display - no filtering\n\t *  @type array\n\t *  @default []\n\t */\n\t\"aiDisplayMaster\": [],\n\n\t/**\n\t * Map of row ids to data indexes\n\t *  @type object\n\t *  @default {}\n\t */\n\t\"aIds\": {},\n\n\t/**\n\t * Store information about each column that is in use\n\t *  @type array\n\t *  @default []\n\t */\n\t\"aoColumns\": [],\n\n\t/**\n\t * Store information about the table's header\n\t *  @type array\n\t *  @default []\n\t */\n\t\"aoHeader\": [],\n\n\t/**\n\t * Store information about the table's footer\n\t *  @type array\n\t *  @default []\n\t */\n\t\"aoFooter\": [],\n\n\t/**\n\t * Store the applied global search information in case we want to force a\n\t * research or compare the old search to a new one.\n\t * Note that this parameter will be set by the initialisation routine. To\n\t * set a default use {@link DataTable.defaults}.\n\t *  @namespace\n\t *  @extends DataTable.models.oSearch\n\t */\n\t\"oPreviousSearch\": {},\n\n\t/**\n\t * Store the applied search for each column - see\n\t * {@link DataTable.models.oSearch} for the format that is used for the\n\t * filtering information for each column.\n\t *  @type array\n\t *  @default []\n\t */\n\t\"aoPreSearchCols\": [],\n\n\t/**\n\t * Sorting that is applied to the table. Note that the inner arrays are\n\t * used in the following manner:\n\t * <ul>\n\t *   <li>Index 0 - column number</li>\n\t *   <li>Index 1 - current sorting direction</li>\n\t * </ul>\n\t * Note that this parameter will be set by the initialisation routine. To\n\t * set a default use {@link DataTable.defaults}.\n\t *  @type array\n\t *  @todo These inner arrays should really be objects\n\t */\n\t\"aaSorting\": null,\n\n\t/**\n\t * Sorting that is always applied to the table (i.e. prefixed in front of\n\t * aaSorting).\n\t * Note that this parameter will be set by the initialisation routine. To\n\t * set a default use {@link DataTable.defaults}.\n\t *  @type array\n\t *  @default []\n\t */\n\t\"aaSortingFixed\": [],\n\n\t/**\n\t * Classes to use for the striping of a table.\n\t * Note that this parameter will be set by the initialisation routine. To\n\t * set a default use {@link DataTable.defaults}.\n\t *  @type array\n\t *  @default []\n\t */\n\t\"asStripeClasses\": null,\n\n\t/**\n\t * If restoring a table - we should restore its striping classes as well\n\t *  @type array\n\t *  @default []\n\t */\n\t\"asDestroyStripes\": [],\n\n\t/**\n\t * If restoring a table - we should restore its width\n\t *  @type int\n\t *  @default 0\n\t */\n\t\"sDestroyWidth\": 0,\n\n\t/**\n\t * Callback functions array for every time a row is inserted (i.e. on a draw).\n\t *  @type array\n\t *  @default []\n\t */\n\t\"aoRowCallback\": [],\n\n\t/**\n\t * Callback functions for the header on each draw.\n\t *  @type array\n\t *  @default []\n\t */\n\t\"aoHeaderCallback\": [],\n\n\t/**\n\t * Callback function for the footer on each draw.\n\t *  @type array\n\t *  @default []\n\t */\n\t\"aoFooterCallback\": [],\n\n\t/**\n\t * Array of callback functions for draw callback functions\n\t *  @type array\n\t *  @default []\n\t */\n\t\"aoDrawCallback\": [],\n\n\t/**\n\t * Array of callback functions for row created function\n\t *  @type array\n\t *  @default []\n\t */\n\t\"aoRowCreatedCallback\": [],\n\n\t/**\n\t * Callback functions for just before the table is redrawn. A return of\n\t * false will be used to cancel the draw.\n\t *  @type array\n\t *  @default []\n\t */\n\t\"aoPreDrawCallback\": [],\n\n\t/**\n\t * Callback functions for when the table has been initialised.\n\t *  @type array\n\t *  @default []\n\t */\n\t\"aoInitComplete\": [],\n\n\n\t/**\n\t * Callbacks for modifying the settings to be stored for state saving, prior to\n\t * saving state.\n\t *  @type array\n\t *  @default []\n\t */\n\t\"aoStateSaveParams\": [],\n\n\t/**\n\t * Callbacks for modifying the settings that have been stored for state saving\n\t * prior to using the stored values to restore the state.\n\t *  @type array\n\t *  @default []\n\t */\n\t\"aoStateLoadParams\": [],\n\n\t/**\n\t * Callbacks for operating on the settings object once the saved state has been\n\t * loaded\n\t *  @type array\n\t *  @default []\n\t */\n\t\"aoStateLoaded\": [],\n\n\t/**\n\t * Cache the table ID for quick access\n\t *  @type string\n\t *  @default <i>Empty string</i>\n\t */\n\t\"sTableId\": \"\",\n\n\t/**\n\t * The TABLE node for the main table\n\t *  @type node\n\t *  @default null\n\t */\n\t\"nTable\": null,\n\n\t/**\n\t * Permanent ref to the thead element\n\t *  @type node\n\t *  @default null\n\t */\n\t\"nTHead\": null,\n\n\t/**\n\t * Permanent ref to the tfoot element - if it exists\n\t *  @type node\n\t *  @default null\n\t */\n\t\"nTFoot\": null,\n\n\t/**\n\t * Permanent ref to the tbody element\n\t *  @type node\n\t *  @default null\n\t */\n\t\"nTBody\": null,\n\n\t/**\n\t * Cache the wrapper node (contains all DataTables controlled elements)\n\t *  @type node\n\t *  @default null\n\t */\n\t\"nTableWrapper\": null,\n\n\t/**\n\t * Indicate if when using server-side processing the loading of data\n\t * should be deferred until the second draw.\n\t * Note that this parameter will be set by the initialisation routine. To\n\t * set a default use {@link DataTable.defaults}.\n\t *  @type boolean\n\t *  @default false\n\t */\n\t\"bDeferLoading\": false,\n\n\t/**\n\t * Indicate if all required information has been read in\n\t *  @type boolean\n\t *  @default false\n\t */\n\t\"bInitialised\": false,\n\n\t/**\n\t * Information about open rows. Each object in the array has the parameters\n\t * 'nTr' and 'nParent'\n\t *  @type array\n\t *  @default []\n\t */\n\t\"aoOpenRows\": [],\n\n\t/**\n\t * Dictate the positioning of DataTables' control elements - see\n\t * {@link DataTable.model.oInit.sDom}.\n\t * Note that this parameter will be set by the initialisation routine. To\n\t * set a default use {@link DataTable.defaults}.\n\t *  @type string\n\t *  @default null\n\t */\n\t\"sDom\": null,\n\n\t/**\n\t * Search delay (in mS)\n\t *  @type integer\n\t *  @default null\n\t */\n\t\"searchDelay\": null,\n\n\t/**\n\t * Which type of pagination should be used.\n\t * Note that this parameter will be set by the initialisation routine. To\n\t * set a default use {@link DataTable.defaults}.\n\t *  @type string\n\t *  @default two_button\n\t */\n\t\"sPaginationType\": \"two_button\",\n\n\t/**\n\t * The state duration (for `stateSave`) in seconds.\n\t * Note that this parameter will be set by the initialisation routine. To\n\t * set a default use {@link DataTable.defaults}.\n\t *  @type int\n\t *  @default 0\n\t */\n\t\"iStateDuration\": 0,\n\n\t/**\n\t * Array of callback functions for state saving. Each array element is an\n\t * object with the following parameters:\n\t *   <ul>\n\t *     <li>function:fn - function to call. Takes two parameters, oSettings\n\t *       and the JSON string to save that has been thus far created. Returns\n\t *       a JSON string to be inserted into a json object\n\t *       (i.e. '\"param\": [ 0, 1, 2]')</li>\n\t *     <li>string:sName - name of callback</li>\n\t *   </ul>\n\t *  @type array\n\t *  @default []\n\t */\n\t\"aoStateSave\": [],\n\n\t/**\n\t * Array of callback functions for state loading. Each array element is an\n\t * object with the following parameters:\n\t *   <ul>\n\t *     <li>function:fn - function to call. Takes two parameters, oSettings\n\t *       and the object stored. May return false to cancel state loading</li>\n\t *     <li>string:sName - name of callback</li>\n\t *   </ul>\n\t *  @type array\n\t *  @default []\n\t */\n\t\"aoStateLoad\": [],\n\n\t/**\n\t * State that was saved. Useful for back reference\n\t *  @type object\n\t *  @default null\n\t */\n\t\"oSavedState\": null,\n\n\t/**\n\t * State that was loaded. Useful for back reference\n\t *  @type object\n\t *  @default null\n\t */\n\t\"oLoadedState\": null,\n\n\t/**\n\t * Source url for AJAX data for the table.\n\t * Note that this parameter will be set by the initialisation routine. To\n\t * set a default use {@link DataTable.defaults}.\n\t *  @type string\n\t *  @default null\n\t */\n\t\"sAjaxSource\": null,\n\n\t/**\n\t * Property from a given object from which to read the table data from. This\n\t * can be an empty string (when not server-side processing), in which case\n\t * it is  assumed an an array is given directly.\n\t * Note that this parameter will be set by the initialisation routine. To\n\t * set a default use {@link DataTable.defaults}.\n\t *  @type string\n\t */\n\t\"sAjaxDataProp\": null,\n\n\t/**\n\t * The last jQuery XHR object that was used for server-side data gathering.\n\t * This can be used for working with the XHR information in one of the\n\t * callbacks\n\t *  @type object\n\t *  @default null\n\t */\n\t\"jqXHR\": null,\n\n\t/**\n\t * JSON returned from the server in the last Ajax request\n\t *  @type object\n\t *  @default undefined\n\t */\n\t\"json\": undefined,\n\n\t/**\n\t * Data submitted as part of the last Ajax request\n\t *  @type object\n\t *  @default undefined\n\t */\n\t\"oAjaxData\": undefined,\n\n\t/**\n\t * Function to get the server-side data.\n\t * Note that this parameter will be set by the initialisation routine. To\n\t * set a default use {@link DataTable.defaults}.\n\t *  @type function\n\t */\n\t\"fnServerData\": null,\n\n\t/**\n\t * Functions which are called prior to sending an Ajax request so extra\n\t * parameters can easily be sent to the server\n\t *  @type array\n\t *  @default []\n\t */\n\t\"aoServerParams\": [],\n\n\t/**\n\t * Send the XHR HTTP method - GET or POST (could be PUT or DELETE if\n\t * required).\n\t * Note that this parameter will be set by the initialisation routine. To\n\t * set a default use {@link DataTable.defaults}.\n\t *  @type string\n\t */\n\t\"sServerMethod\": null,\n\n\t/**\n\t * Format numbers for display.\n\t * Note that this parameter will be set by the initialisation routine. To\n\t * set a default use {@link DataTable.defaults}.\n\t *  @type function\n\t */\n\t\"fnFormatNumber\": null,\n\n\t/**\n\t * List of options that can be used for the user selectable length menu.\n\t * Note that this parameter will be set by the initialisation routine. To\n\t * set a default use {@link DataTable.defaults}.\n\t *  @type array\n\t *  @default []\n\t */\n\t\"aLengthMenu\": null,\n\n\t/**\n\t * Counter for the draws that the table does. Also used as a tracker for\n\t * server-side processing\n\t *  @type int\n\t *  @default 0\n\t */\n\t\"iDraw\": 0,\n\n\t/**\n\t * Indicate if a redraw is being done - useful for Ajax\n\t *  @type boolean\n\t *  @default false\n\t */\n\t\"bDrawing\": false,\n\n\t/**\n\t * Draw index (iDraw) of the last error when parsing the returned data\n\t *  @type int\n\t *  @default -1\n\t */\n\t\"iDrawError\": -1,\n\n\t/**\n\t * Paging display length\n\t *  @type int\n\t *  @default 10\n\t */\n\t\"_iDisplayLength\": 10,\n\n\t/**\n\t * Paging start point - aiDisplay index\n\t *  @type int\n\t *  @default 0\n\t */\n\t\"_iDisplayStart\": 0,\n\n\t/**\n\t * Server-side processing - number of records in the result set\n\t * (i.e. before filtering), Use fnRecordsTotal rather than\n\t * this property to get the value of the number of records, regardless of\n\t * the server-side processing setting.\n\t *  @type int\n\t *  @default 0\n\t *  @private\n\t */\n\t\"_iRecordsTotal\": 0,\n\n\t/**\n\t * Server-side processing - number of records in the current display set\n\t * (i.e. after filtering). Use fnRecordsDisplay rather than\n\t * this property to get the value of the number of records, regardless of\n\t * the server-side processing setting.\n\t *  @type boolean\n\t *  @default 0\n\t *  @private\n\t */\n\t\"_iRecordsDisplay\": 0,\n\n\t/**\n\t * The classes to use for the table\n\t *  @type object\n\t *  @default {}\n\t */\n\t\"oClasses\": {},\n\n\t/**\n\t * Flag attached to the settings object so you can check in the draw\n\t * callback if filtering has been done in the draw. Deprecated in favour of\n\t * events.\n\t *  @type boolean\n\t *  @default false\n\t *  @deprecated\n\t */\n\t\"bFiltered\": false,\n\n\t/**\n\t * Flag attached to the settings object so you can check in the draw\n\t * callback if sorting has been done in the draw. Deprecated in favour of\n\t * events.\n\t *  @type boolean\n\t *  @default false\n\t *  @deprecated\n\t */\n\t\"bSorted\": false,\n\n\t/**\n\t * Indicate that if multiple rows are in the header and there is more than\n\t * one unique cell per column, if the top one (true) or bottom one (false)\n\t * should be used for sorting / title by DataTables.\n\t * Note that this parameter will be set by the initialisation routine. To\n\t * set a default use {@link DataTable.defaults}.\n\t *  @type boolean\n\t */\n\t\"bSortCellsTop\": null,\n\n\t/**\n\t * Initialisation object that is used for the table\n\t *  @type object\n\t *  @default null\n\t */\n\t\"oInit\": null,\n\n\t/**\n\t * Destroy callback functions - for plug-ins to attach themselves to the\n\t * destroy so they can clean up markup and events.\n\t *  @type array\n\t *  @default []\n\t */\n\t\"aoDestroyCallback\": [],\n\n\n\t/**\n\t * Get the number of records in the current record set, before filtering\n\t *  @type function\n\t */\n\t\"fnRecordsTotal\": function ()\n\t{\n\t\treturn _fnDataSource( this ) == 'ssp' ?\n\t\t\tthis._iRecordsTotal * 1 :\n\t\t\tthis.aiDisplayMaster.length;\n\t},\n\n\t/**\n\t * Get the number of records in the current record set, after filtering\n\t *  @type function\n\t */\n\t\"fnRecordsDisplay\": function ()\n\t{\n\t\treturn _fnDataSource( this ) == 'ssp' ?\n\t\t\tthis._iRecordsDisplay * 1 :\n\t\t\tthis.aiDisplay.length;\n\t},\n\n\t/**\n\t * Get the display end point - aiDisplay index\n\t *  @type function\n\t */\n\t\"fnDisplayEnd\": function ()\n\t{\n\t\tvar\n\t\t\tlen      = this._iDisplayLength,\n\t\t\tstart    = this._iDisplayStart,\n\t\t\tcalc     = start + len,\n\t\t\trecords  = this.aiDisplay.length,\n\t\t\tfeatures = this.oFeatures,\n\t\t\tpaginate = features.bPaginate;\n\n\t\tif ( features.bServerSide ) {\n\t\t\treturn paginate === false || len === -1 ?\n\t\t\t\tstart + records :\n\t\t\t\tMath.min( start+len, this._iRecordsDisplay );\n\t\t}\n\t\telse {\n\t\t\treturn ! paginate || calc>records || len===-1 ?\n\t\t\t\trecords :\n\t\t\t\tcalc;\n\t\t}\n\t},\n\n\t/**\n\t * The DataTables object for this table\n\t *  @type object\n\t *  @default null\n\t */\n\t\"oInstance\": null,\n\n\t/**\n\t * Unique identifier for each instance of the DataTables object. If there\n\t * is an ID on the table node, then it takes that value, otherwise an\n\t * incrementing internal counter is used.\n\t *  @type string\n\t *  @default null\n\t */\n\t\"sInstance\": null,\n\n\t/**\n\t * tabindex attribute value that is added to DataTables control elements, allowing\n\t * keyboard navigation of the table and its controls.\n\t */\n\t\"iTabIndex\": 0,\n\n\t/**\n\t * DIV container for the footer scrolling table if scrolling\n\t */\n\t\"nScrollHead\": null,\n\n\t/**\n\t * DIV container for the footer scrolling table if scrolling\n\t */\n\t\"nScrollFoot\": null,\n\n\t/**\n\t * Last applied sort\n\t *  @type array\n\t *  @default []\n\t */\n\t\"aLastSort\": [],\n\n\t/**\n\t * Stored plug-in instances\n\t *  @type object\n\t *  @default {}\n\t */\n\t\"oPlugins\": {},\n\n\t/**\n\t * Function used to get a row's id from the row's data\n\t *  @type function\n\t *  @default null\n\t */\n\t\"rowIdFn\": null,\n\n\t/**\n\t * Data location where to store a row's id\n\t *  @type string\n\t *  @default null\n\t */\n\t\"rowId\": null\n};\n\n/**\n * Extension object for DataTables that is used to provide all extension\n * options.\n *\n * Note that the `DataTable.ext` object is available through\n * `jQuery.fn.dataTable.ext` where it may be accessed and manipulated. It is\n * also aliased to `jQuery.fn.dataTableExt` for historic reasons.\n *  @namespace\n *  @extends DataTable.models.ext\n */\n\n\n/**\n * DataTables extensions\n * \n * This namespace acts as a collection area for plug-ins that can be used to\n * extend DataTables capabilities. Indeed many of the build in methods\n * use this method to provide their own capabilities (sorting methods for\n * example).\n *\n * Note that this namespace is aliased to `jQuery.fn.dataTableExt` for legacy\n * reasons\n *\n *  @namespace\n */\nDataTable.ext = _ext = {\n\t/**\n\t * Buttons. For use with the Buttons extension for DataTables. This is\n\t * defined here so other extensions can define buttons regardless of load\n\t * order. It is _not_ used by DataTables core.\n\t *\n\t *  @type object\n\t *  @default {}\n\t */\n\tbuttons: {},\n\n\n\t/**\n\t * Element class names\n\t *\n\t *  @type object\n\t *  @default {}\n\t */\n\tclasses: {},\n\n\n\t/**\n\t * DataTables build type (expanded by the download builder)\n\t *\n\t *  @type string\n\t */\n\tbuilder: \"-source-\",\n\n\n\t/**\n\t * Error reporting.\n\t * \n\t * How should DataTables report an error. Can take the value 'alert',\n\t * 'throw', 'none' or a function.\n\t *\n\t *  @type string|function\n\t *  @default alert\n\t */\n\terrMode: \"alert\",\n\n\n\t/**\n\t * Feature plug-ins.\n\t * \n\t * This is an array of objects which describe the feature plug-ins that are\n\t * available to DataTables. These feature plug-ins are then available for\n\t * use through the `dom` initialisation option.\n\t * \n\t * Each feature plug-in is described by an object which must have the\n\t * following properties:\n\t * \n\t * * `fnInit` - function that is used to initialise the plug-in,\n\t * * `cFeature` - a character so the feature can be enabled by the `dom`\n\t *   instillation option. This is case sensitive.\n\t *\n\t * The `fnInit` function has the following input parameters:\n\t *\n\t * 1. `{object}` DataTables settings object: see\n\t *    {@link DataTable.models.oSettings}\n\t *\n\t * And the following return is expected:\n\t * \n\t * * {node|null} The element which contains your feature. Note that the\n\t *   return may also be void if your plug-in does not require to inject any\n\t *   DOM elements into DataTables control (`dom`) - for example this might\n\t *   be useful when developing a plug-in which allows table control via\n\t *   keyboard entry\n\t *\n\t *  @type array\n\t *\n\t *  @example\n\t *    $.fn.dataTable.ext.features.push( {\n\t *      \"fnInit\": function( oSettings ) {\n\t *        return new TableTools( { \"oDTSettings\": oSettings } );\n\t *      },\n\t *      \"cFeature\": \"T\"\n\t *    } );\n\t */\n\tfeature: [],\n\n\n\t/**\n\t * Row searching.\n\t * \n\t * This method of searching is complimentary to the default type based\n\t * searching, and a lot more comprehensive as it allows you complete control\n\t * over the searching logic. Each element in this array is a function\n\t * (parameters described below) that is called for every row in the table,\n\t * and your logic decides if it should be included in the searching data set\n\t * or not.\n\t *\n\t * Searching functions have the following input parameters:\n\t *\n\t * 1. `{object}` DataTables settings object: see\n\t *    {@link DataTable.models.oSettings}\n\t * 2. `{array|object}` Data for the row to be processed (same as the\n\t *    original format that was passed in as the data source, or an array\n\t *    from a DOM data source\n\t * 3. `{int}` Row index ({@link DataTable.models.oSettings.aoData}), which\n\t *    can be useful to retrieve the `TR` element if you need DOM interaction.\n\t *\n\t * And the following return is expected:\n\t *\n\t * * {boolean} Include the row in the searched result set (true) or not\n\t *   (false)\n\t *\n\t * Note that as with the main search ability in DataTables, technically this\n\t * is \"filtering\", since it is subtractive. However, for consistency in\n\t * naming we call it searching here.\n\t *\n\t *  @type array\n\t *  @default []\n\t *\n\t *  @example\n\t *    // The following example shows custom search being applied to the\n\t *    // fourth column (i.e. the data[3] index) based on two input values\n\t *    // from the end-user, matching the data in a certain range.\n\t *    $.fn.dataTable.ext.search.push(\n\t *      function( settings, data, dataIndex ) {\n\t *        var min = document.getElementById('min').value * 1;\n\t *        var max = document.getElementById('max').value * 1;\n\t *        var version = data[3] == \"-\" ? 0 : data[3]*1;\n\t *\n\t *        if ( min == \"\" && max == \"\" ) {\n\t *          return true;\n\t *        }\n\t *        else if ( min == \"\" && version < max ) {\n\t *          return true;\n\t *        }\n\t *        else if ( min < version && \"\" == max ) {\n\t *          return true;\n\t *        }\n\t *        else if ( min < version && version < max ) {\n\t *          return true;\n\t *        }\n\t *        return false;\n\t *      }\n\t *    );\n\t */\n\tsearch: [],\n\n\n\t/**\n\t * Selector extensions\n\t *\n\t * The `selector` option can be used to extend the options available for the\n\t * selector modifier options (`selector-modifier` object data type) that\n\t * each of the three built in selector types offer (row, column and cell +\n\t * their plural counterparts). For example the Select extension uses this\n\t * mechanism to provide an option to select only rows, columns and cells\n\t * that have been marked as selected by the end user (`{selected: true}`),\n\t * which can be used in conjunction with the existing built in selector\n\t * options.\n\t *\n\t * Each property is an array to which functions can be pushed. The functions\n\t * take three attributes:\n\t *\n\t * * Settings object for the host table\n\t * * Options object (`selector-modifier` object type)\n\t * * Array of selected item indexes\n\t *\n\t * The return is an array of the resulting item indexes after the custom\n\t * selector has been applied.\n\t *\n\t *  @type object\n\t */\n\tselector: {\n\t\tcell: [],\n\t\tcolumn: [],\n\t\trow: []\n\t},\n\n\n\t/**\n\t * Internal functions, exposed for used in plug-ins.\n\t * \n\t * Please note that you should not need to use the internal methods for\n\t * anything other than a plug-in (and even then, try to avoid if possible).\n\t * The internal function may change between releases.\n\t *\n\t *  @type object\n\t *  @default {}\n\t */\n\tinternal: {},\n\n\n\t/**\n\t * Legacy configuration options. Enable and disable legacy options that\n\t * are available in DataTables.\n\t *\n\t *  @type object\n\t */\n\tlegacy: {\n\t\t/**\n\t\t * Enable / disable DataTables 1.9 compatible server-side processing\n\t\t * requests\n\t\t *\n\t\t *  @type boolean\n\t\t *  @default null\n\t\t */\n\t\tajax: null\n\t},\n\n\n\t/**\n\t * Pagination plug-in methods.\n\t * \n\t * Each entry in this object is a function and defines which buttons should\n\t * be shown by the pagination rendering method that is used for the table:\n\t * {@link DataTable.ext.renderer.pageButton}. The renderer addresses how the\n\t * buttons are displayed in the document, while the functions here tell it\n\t * what buttons to display. This is done by returning an array of button\n\t * descriptions (what each button will do).\n\t *\n\t * Pagination types (the four built in options and any additional plug-in\n\t * options defined here) can be used through the `paginationType`\n\t * initialisation parameter.\n\t *\n\t * The functions defined take two parameters:\n\t *\n\t * 1. `{int} page` The current page index\n\t * 2. `{int} pages` The number of pages in the table\n\t *\n\t * Each function is expected to return an array where each element of the\n\t * array can be one of:\n\t *\n\t * * `first` - Jump to first page when activated\n\t * * `last` - Jump to last page when activated\n\t * * `previous` - Show previous page when activated\n\t * * `next` - Show next page when activated\n\t * * `{int}` - Show page of the index given\n\t * * `{array}` - A nested array containing the above elements to add a\n\t *   containing 'DIV' element (might be useful for styling).\n\t *\n\t * Note that DataTables v1.9- used this object slightly differently whereby\n\t * an object with two functions would be defined for each plug-in. That\n\t * ability is still supported by DataTables 1.10+ to provide backwards\n\t * compatibility, but this option of use is now decremented and no longer\n\t * documented in DataTables 1.10+.\n\t *\n\t *  @type object\n\t *  @default {}\n\t *\n\t *  @example\n\t *    // Show previous, next and current page buttons only\n\t *    $.fn.dataTableExt.oPagination.current = function ( page, pages ) {\n\t *      return [ 'previous', page, 'next' ];\n\t *    };\n\t */\n\tpager: {},\n\n\n\trenderer: {\n\t\tpageButton: {},\n\t\theader: {}\n\t},\n\n\n\t/**\n\t * Ordering plug-ins - custom data source\n\t * \n\t * The extension options for ordering of data available here is complimentary\n\t * to the default type based ordering that DataTables typically uses. It\n\t * allows much greater control over the the data that is being used to\n\t * order a column, but is necessarily therefore more complex.\n\t * \n\t * This type of ordering is useful if you want to do ordering based on data\n\t * live from the DOM (for example the contents of an 'input' element) rather\n\t * than just the static string that DataTables knows of.\n\t * \n\t * The way these plug-ins work is that you create an array of the values you\n\t * wish to be ordering for the column in question and then return that\n\t * array. The data in the array much be in the index order of the rows in\n\t * the table (not the currently ordering order!). Which order data gathering\n\t * function is run here depends on the `dt-init columns.orderDataType`\n\t * parameter that is used for the column (if any).\n\t *\n\t * The functions defined take two parameters:\n\t *\n\t * 1. `{object}` DataTables settings object: see\n\t *    {@link DataTable.models.oSettings}\n\t * 2. `{int}` Target column index\n\t *\n\t * Each function is expected to return an array:\n\t *\n\t * * `{array}` Data for the column to be ordering upon\n\t *\n\t *  @type array\n\t *\n\t *  @example\n\t *    // Ordering using `input` node values\n\t *    $.fn.dataTable.ext.order['dom-text'] = function  ( settings, col )\n\t *    {\n\t *      return this.api().column( col, {order:'index'} ).nodes().map( function ( td, i ) {\n\t *        return $('input', td).val();\n\t *      } );\n\t *    }\n\t */\n\torder: {},\n\n\n\t/**\n\t * Type based plug-ins.\n\t *\n\t * Each column in DataTables has a type assigned to it, either by automatic\n\t * detection or by direct assignment using the `type` option for the column.\n\t * The type of a column will effect how it is ordering and search (plug-ins\n\t * can also make use of the column type if required).\n\t *\n\t * @namespace\n\t */\n\ttype: {\n\t\t/**\n\t\t * Type detection functions.\n\t\t *\n\t\t * The functions defined in this object are used to automatically detect\n\t\t * a column's type, making initialisation of DataTables super easy, even\n\t\t * when complex data is in the table.\n\t\t *\n\t\t * The functions defined take two parameters:\n\t\t *\n\t     *  1. `{*}` Data from the column cell to be analysed\n\t     *  2. `{settings}` DataTables settings object. This can be used to\n\t     *     perform context specific type detection - for example detection\n\t     *     based on language settings such as using a comma for a decimal\n\t     *     place. Generally speaking the options from the settings will not\n\t     *     be required\n\t\t *\n\t\t * Each function is expected to return:\n\t\t *\n\t\t * * `{string|null}` Data type detected, or null if unknown (and thus\n\t\t *   pass it on to the other type detection functions.\n\t\t *\n\t\t *  @type array\n\t\t *\n\t\t *  @example\n\t\t *    // Currency type detection plug-in:\n\t\t *    $.fn.dataTable.ext.type.detect.push(\n\t\t *      function ( data, settings ) {\n\t\t *        // Check the numeric part\n\t\t *        if ( ! data.substring(1).match(/[0-9]/) ) {\n\t\t *          return null;\n\t\t *        }\n\t\t *\n\t\t *        // Check prefixed by currency\n\t\t *        if ( data.charAt(0) == '$' || data.charAt(0) == '&pound;' ) {\n\t\t *          return 'currency';\n\t\t *        }\n\t\t *        return null;\n\t\t *      }\n\t\t *    );\n\t\t */\n\t\tdetect: [],\n\n\n\t\t/**\n\t\t * Type based search formatting.\n\t\t *\n\t\t * The type based searching functions can be used to pre-format the\n\t\t * data to be search on. For example, it can be used to strip HTML\n\t\t * tags or to de-format telephone numbers for numeric only searching.\n\t\t *\n\t\t * Note that is a search is not defined for a column of a given type,\n\t\t * no search formatting will be performed.\n\t\t * \n\t\t * Pre-processing of searching data plug-ins - When you assign the sType\n\t\t * for a column (or have it automatically detected for you by DataTables\n\t\t * or a type detection plug-in), you will typically be using this for\n\t\t * custom sorting, but it can also be used to provide custom searching\n\t\t * by allowing you to pre-processing the data and returning the data in\n\t\t * the format that should be searched upon. This is done by adding\n\t\t * functions this object with a parameter name which matches the sType\n\t\t * for that target column. This is the corollary of <i>afnSortData</i>\n\t\t * for searching data.\n\t\t *\n\t\t * The functions defined take a single parameter:\n\t\t *\n\t     *  1. `{*}` Data from the column cell to be prepared for searching\n\t\t *\n\t\t * Each function is expected to return:\n\t\t *\n\t\t * * `{string|null}` Formatted string that will be used for the searching.\n\t\t *\n\t\t *  @type object\n\t\t *  @default {}\n\t\t *\n\t\t *  @example\n\t\t *    $.fn.dataTable.ext.type.search['title-numeric'] = function ( d ) {\n\t\t *      return d.replace(/\\n/g,\" \").replace( /<.*?>/g, \"\" );\n\t\t *    }\n\t\t */\n\t\tsearch: {},\n\n\n\t\t/**\n\t\t * Type based ordering.\n\t\t *\n\t\t * The column type tells DataTables what ordering to apply to the table\n\t\t * when a column is sorted upon. The order for each type that is defined,\n\t\t * is defined by the functions available in this object.\n\t\t *\n\t\t * Each ordering option can be described by three properties added to\n\t\t * this object:\n\t\t *\n\t\t * * `{type}-pre` - Pre-formatting function\n\t\t * * `{type}-asc` - Ascending order function\n\t\t * * `{type}-desc` - Descending order function\n\t\t *\n\t\t * All three can be used together, only `{type}-pre` or only\n\t\t * `{type}-asc` and `{type}-desc` together. It is generally recommended\n\t\t * that only `{type}-pre` is used, as this provides the optimal\n\t\t * implementation in terms of speed, although the others are provided\n\t\t * for compatibility with existing Javascript sort functions.\n\t\t *\n\t\t * `{type}-pre`: Functions defined take a single parameter:\n\t\t *\n\t     *  1. `{*}` Data from the column cell to be prepared for ordering\n\t\t *\n\t\t * And return:\n\t\t *\n\t\t * * `{*}` Data to be sorted upon\n\t\t *\n\t\t * `{type}-asc` and `{type}-desc`: Functions are typical Javascript sort\n\t\t * functions, taking two parameters:\n\t\t *\n\t     *  1. `{*}` Data to compare to the second parameter\n\t     *  2. `{*}` Data to compare to the first parameter\n\t\t *\n\t\t * And returning:\n\t\t *\n\t\t * * `{*}` Ordering match: <0 if first parameter should be sorted lower\n\t\t *   than the second parameter, ===0 if the two parameters are equal and\n\t\t *   >0 if the first parameter should be sorted height than the second\n\t\t *   parameter.\n\t\t * \n\t\t *  @type object\n\t\t *  @default {}\n\t\t *\n\t\t *  @example\n\t\t *    // Numeric ordering of formatted numbers with a pre-formatter\n\t\t *    $.extend( $.fn.dataTable.ext.type.order, {\n\t\t *      \"string-pre\": function(x) {\n\t\t *        a = (a === \"-\" || a === \"\") ? 0 : a.replace( /[^\\d\\-\\.]/g, \"\" );\n\t\t *        return parseFloat( a );\n\t\t *      }\n\t\t *    } );\n\t\t *\n\t\t *  @example\n\t\t *    // Case-sensitive string ordering, with no pre-formatting method\n\t\t *    $.extend( $.fn.dataTable.ext.order, {\n\t\t *      \"string-case-asc\": function(x,y) {\n\t\t *        return ((x < y) ? -1 : ((x > y) ? 1 : 0));\n\t\t *      },\n\t\t *      \"string-case-desc\": function(x,y) {\n\t\t *        return ((x < y) ? 1 : ((x > y) ? -1 : 0));\n\t\t *      }\n\t\t *    } );\n\t\t */\n\t\torder: {}\n\t},\n\n\t/**\n\t * Unique DataTables instance counter\n\t *\n\t * @type int\n\t * @private\n\t */\n\t_unique: 0,\n\n\n\t//\n\t// Depreciated\n\t// The following properties are retained for backwards compatibility only.\n\t// The should not be used in new projects and will be removed in a future\n\t// version\n\t//\n\n\t/**\n\t * Version check function.\n\t *  @type function\n\t *  @depreciated Since 1.10\n\t */\n\tfnVersionCheck: DataTable.fnVersionCheck,\n\n\n\t/**\n\t * Index for what 'this' index API functions should use\n\t *  @type int\n\t *  @deprecated Since v1.10\n\t */\n\tiApiIndex: 0,\n\n\n\t/**\n\t * jQuery UI class container\n\t *  @type object\n\t *  @deprecated Since v1.10\n\t */\n\toJUIClasses: {},\n\n\n\t/**\n\t * Software version\n\t *  @type string\n\t *  @deprecated Since v1.10\n\t */\n\tsVersion: DataTable.version\n};\n\n\n//\n// Backwards compatibility. Alias to pre 1.10 Hungarian notation counter parts\n//\n$.extend( _ext, {\n\tafnFiltering: _ext.search,\n\taTypes:       _ext.type.detect,\n\tofnSearch:    _ext.type.search,\n\toSort:        _ext.type.order,\n\tafnSortData:  _ext.order,\n\taoFeatures:   _ext.feature,\n\toApi:         _ext.internal,\n\toStdClasses:  _ext.classes,\n\toPagination:  _ext.pager\n} );\n\n\n$.extend( DataTable.ext.classes, {\n\t\"sTable\": \"dataTable\",\n\t\"sNoFooter\": \"no-footer\",\n\n\t/* Paging buttons */\n\t\"sPageButton\": \"paginate_button\",\n\t\"sPageButtonActive\": \"current\",\n\t\"sPageButtonDisabled\": \"disabled\",\n\n\t/* Striping classes */\n\t\"sStripeOdd\": \"odd\",\n\t\"sStripeEven\": \"even\",\n\n\t/* Empty row */\n\t\"sRowEmpty\": \"dataTables_empty\",\n\n\t/* Features */\n\t\"sWrapper\": \"dataTables_wrapper\",\n\t\"sFilter\": \"dataTables_filter\",\n\t\"sInfo\": \"dataTables_info\",\n\t\"sPaging\": \"dataTables_paginate paging_\", /* Note that the type is postfixed */\n\t\"sLength\": \"dataTables_length\",\n\t\"sProcessing\": \"dataTables_processing\",\n\n\t/* Sorting */\n\t\"sSortAsc\": \"sorting_asc\",\n\t\"sSortDesc\": \"sorting_desc\",\n\t\"sSortable\": \"sorting\", /* Sortable in both directions */\n\t\"sSortableAsc\": \"sorting_desc_disabled\",\n\t\"sSortableDesc\": \"sorting_asc_disabled\",\n\t\"sSortableNone\": \"sorting_disabled\",\n\t\"sSortColumn\": \"sorting_\", /* Note that an int is postfixed for the sorting order */\n\n\t/* Filtering */\n\t\"sFilterInput\": \"\",\n\n\t/* Page length */\n\t\"sLengthSelect\": \"\",\n\n\t/* Scrolling */\n\t\"sScrollWrapper\": \"dataTables_scroll\",\n\t\"sScrollHead\": \"dataTables_scrollHead\",\n\t\"sScrollHeadInner\": \"dataTables_scrollHeadInner\",\n\t\"sScrollBody\": \"dataTables_scrollBody\",\n\t\"sScrollFoot\": \"dataTables_scrollFoot\",\n\t\"sScrollFootInner\": \"dataTables_scrollFootInner\",\n\n\t/* Misc */\n\t\"sHeaderTH\": \"\",\n\t\"sFooterTH\": \"\",\n\n\t// Deprecated\n\t\"sSortJUIAsc\": \"\",\n\t\"sSortJUIDesc\": \"\",\n\t\"sSortJUI\": \"\",\n\t\"sSortJUIAscAllowed\": \"\",\n\t\"sSortJUIDescAllowed\": \"\",\n\t\"sSortJUIWrapper\": \"\",\n\t\"sSortIcon\": \"\",\n\t\"sJUIHeader\": \"\",\n\t\"sJUIFooter\": \"\"\n} );\n\n\nvar extPagination = DataTable.ext.pager;\n\nfunction _numbers ( page, pages ) {\n\tvar\n\t\tnumbers = [],\n\t\tbuttons = extPagination.numbers_length,\n\t\thalf = Math.floor( buttons / 2 ),\n\t\ti = 1;\n\n\tif ( pages <= buttons ) {\n\t\tnumbers = _range( 0, pages );\n\t}\n\telse if ( page <= half ) {\n\t\tnumbers = _range( 0, buttons-2 );\n\t\tnumbers.push( 'ellipsis' );\n\t\tnumbers.push( pages-1 );\n\t}\n\telse if ( page >= pages - 1 - half ) {\n\t\tnumbers = _range( pages-(buttons-2), pages );\n\t\tnumbers.splice( 0, 0, 'ellipsis' ); // no unshift in ie6\n\t\tnumbers.splice( 0, 0, 0 );\n\t}\n\telse {\n\t\tnumbers = _range( page-half+2, page+half-1 );\n\t\tnumbers.push( 'ellipsis' );\n\t\tnumbers.push( pages-1 );\n\t\tnumbers.splice( 0, 0, 'ellipsis' );\n\t\tnumbers.splice( 0, 0, 0 );\n\t}\n\n\tnumbers.DT_el = 'span';\n\treturn numbers;\n}\n\n\n$.extend( extPagination, {\n\tsimple: function ( page, pages ) {\n\t\treturn [ 'previous', 'next' ];\n\t},\n\n\tfull: function ( page, pages ) {\n\t\treturn [  'first', 'previous', 'next', 'last' ];\n\t},\n\n\tnumbers: function ( page, pages ) {\n\t\treturn [ _numbers(page, pages) ];\n\t},\n\n\tsimple_numbers: function ( page, pages ) {\n\t\treturn [ 'previous', _numbers(page, pages), 'next' ];\n\t},\n\n\tfull_numbers: function ( page, pages ) {\n\t\treturn [ 'first', 'previous', _numbers(page, pages), 'next', 'last' ];\n\t},\n\t\n\tfirst_last_numbers: function (page, pages) {\n \t\treturn ['first', _numbers(page, pages), 'last'];\n \t},\n\n\t// For testing and plug-ins to use\n\t_numbers: _numbers,\n\n\t// Number of number buttons (including ellipsis) to show. _Must be odd!_\n\tnumbers_length: 7\n} );\n\n\n$.extend( true, DataTable.ext.renderer, {\n\tpageButton: {\n\t\t_: function ( settings, host, idx, buttons, page, pages ) {\n\t\t\tvar classes = settings.oClasses;\n\t\t\tvar lang = settings.oLanguage.oPaginate;\n\t\t\tvar aria = settings.oLanguage.oAria.paginate || {};\n\t\t\tvar btnDisplay, btnClass;\n\n\t\t\tvar attach = function( container, buttons ) {\n\t\t\t\tvar i, ien, node, button;\n\t\t\t\tvar disabledClass = classes.sPageButtonDisabled;\n\t\t\t\tvar clickHandler = function ( e ) {\n\t\t\t\t\t_fnPageChange( settings, e.data.action, true );\n\t\t\t\t};\n\n\t\t\t\tfor ( i=0, ien=buttons.length ; i<ien ; i++ ) {\n\t\t\t\t\tbutton = buttons[i];\n\n\t\t\t\t\tif ( Array.isArray( button ) ) {\n\t\t\t\t\t\tvar inner = $( '<'+(button.DT_el || 'div')+'/>' )\n\t\t\t\t\t\t\t.appendTo( container );\n\t\t\t\t\t\tattach( inner, button );\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\tvar disabled = false;\n\n\t\t\t\t\t\tbtnDisplay = null;\n\t\t\t\t\t\tbtnClass = button;\n\n\t\t\t\t\t\tswitch ( button ) {\n\t\t\t\t\t\t\tcase 'ellipsis':\n\t\t\t\t\t\t\t\tcontainer.append('<span class=\"ellipsis\">&#x2026;</span>');\n\t\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\t\tcase 'first':\n\t\t\t\t\t\t\t\tbtnDisplay = lang.sFirst;\n\n\t\t\t\t\t\t\t\tif ( page === 0 ) {\n\t\t\t\t\t\t\t\t\tdisabled = true;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\t\tcase 'previous':\n\t\t\t\t\t\t\t\tbtnDisplay = lang.sPrevious;\n\n\t\t\t\t\t\t\t\tif ( page === 0 ) {\n\t\t\t\t\t\t\t\t\tdisabled = true;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\t\tcase 'next':\n\t\t\t\t\t\t\t\tbtnDisplay = lang.sNext;\n\n\t\t\t\t\t\t\t\tif ( pages === 0 || page === pages-1 ) {\n\t\t\t\t\t\t\t\t\tdisabled = true;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\t\tcase 'last':\n\t\t\t\t\t\t\t\tbtnDisplay = lang.sLast;\n\n\t\t\t\t\t\t\t\tif ( pages === 0 || page === pages-1 ) {\n\t\t\t\t\t\t\t\t\tdisabled = true;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tbreak;\n\n\t\t\t\t\t\t\tdefault:\n\t\t\t\t\t\t\t\tbtnDisplay = settings.fnFormatNumber( button + 1 );\n\t\t\t\t\t\t\t\tbtnClass = page === button ?\n\t\t\t\t\t\t\t\t\tclasses.sPageButtonActive : '';\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tif ( btnDisplay !== null ) {\n\t\t\t\t\t\t\tvar tag = settings.oInit.pagingTag || 'a';\n\n\t\t\t\t\t\t\tif (disabled) {\n\t\t\t\t\t\t\t\tbtnClass += ' ' + disabledClass;\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\tnode = $('<'+tag+'>', {\n\t\t\t\t\t\t\t\t\t'class': classes.sPageButton+' '+btnClass,\n\t\t\t\t\t\t\t\t\t'aria-controls': settings.sTableId,\n\t\t\t\t\t\t\t\t\t'aria-disabled': disabled ? 'true' : null,\n\t\t\t\t\t\t\t\t\t'aria-label': aria[ button ],\n\t\t\t\t\t\t\t\t\t'role': 'link',\n\t\t\t\t\t\t\t\t\t'aria-current': btnClass === classes.sPageButtonActive ? 'page' : null,\n\t\t\t\t\t\t\t\t\t'data-dt-idx': button,\n\t\t\t\t\t\t\t\t\t'tabindex': disabled ? -1 : settings.iTabIndex,\n\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\tsettings.sTableId +'_'+ button :\n\t\t\t\t\t\t\t\t\t\tnull\n\t\t\t\t\t\t\t\t} )\n\t\t\t\t\t\t\t\t.html( btnDisplay )\n\t\t\t\t\t\t\t\t.appendTo( container );\n\n\t\t\t\t\t\t\t_fnBindAction(\n\t\t\t\t\t\t\t\tnode, {action: button}, clickHandler\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\n\t\t\t// IE9 throws an 'unknown error' if document.activeElement is used\n\t\t\t// inside an iframe or frame. Try / catch the error. Not good for\n\t\t\t// accessibility, but neither are frames.\n\t\t\tvar activeEl;\n\n\t\t\ttry {\n\t\t\t\t// Because this approach is destroying and recreating the paging\n\t\t\t\t// elements, focus is lost on the select button which is bad for\n\t\t\t\t// accessibility. So we want to restore focus once the draw has\n\t\t\t\t// completed\n\t\t\t\tactiveEl = $(host).find(document.activeElement).data('dt-idx');\n\t\t\t}\n\t\t\tcatch (e) {}\n\n\t\t\tattach( $(host).empty(), buttons );\n\n\t\t\tif ( activeEl !== undefined ) {\n\t\t\t\t$(host).find( '[data-dt-idx='+activeEl+']' ).trigger('focus');\n\t\t\t}\n\t\t}\n\t}\n} );\n\n\n\n// Built in type detection. See model.ext.aTypes for information about\n// what is required from this methods.\n$.extend( DataTable.ext.type.detect, [\n\t// Plain numbers - first since V8 detects some plain numbers as dates\n\t// e.g. Date.parse('55') (but not all, e.g. Date.parse('22')...).\n\tfunction ( d, settings )\n\t{\n\t\tvar decimal = settings.oLanguage.sDecimal;\n\t\treturn _isNumber( d, decimal ) ? 'num'+decimal : null;\n\t},\n\n\t// Dates (only those recognised by the browser's Date.parse)\n\tfunction ( d, settings )\n\t{\n\t\t// V8 tries _very_ hard to make a string passed into `Date.parse()`\n\t\t// valid, so we need to use a regex to restrict date formats. Use a\n\t\t// plug-in for anything other than ISO8601 style strings\n\t\tif ( d && !(d instanceof Date) && ! _re_date.test(d) ) {\n\t\t\treturn null;\n\t\t}\n\t\tvar parsed = Date.parse(d);\n\t\treturn (parsed !== null && !isNaN(parsed)) || _empty(d) ? 'date' : null;\n\t},\n\n\t// Formatted numbers\n\tfunction ( d, settings )\n\t{\n\t\tvar decimal = settings.oLanguage.sDecimal;\n\t\treturn _isNumber( d, decimal, true ) ? 'num-fmt'+decimal : null;\n\t},\n\n\t// HTML numeric\n\tfunction ( d, settings )\n\t{\n\t\tvar decimal = settings.oLanguage.sDecimal;\n\t\treturn _htmlNumeric( d, decimal ) ? 'html-num'+decimal : null;\n\t},\n\n\t// HTML numeric, formatted\n\tfunction ( d, settings )\n\t{\n\t\tvar decimal = settings.oLanguage.sDecimal;\n\t\treturn _htmlNumeric( d, decimal, true ) ? 'html-num-fmt'+decimal : null;\n\t},\n\n\t// HTML (this is strict checking - there must be html)\n\tfunction ( d, settings )\n\t{\n\t\treturn _empty( d ) || (typeof d === 'string' && d.indexOf('<') !== -1) ?\n\t\t\t'html' : null;\n\t}\n] );\n\n\n\n// Filter formatting functions. See model.ext.ofnSearch for information about\n// what is required from these methods.\n// \n// Note that additional search methods are added for the html numbers and\n// html formatted numbers by `_addNumericSort()` when we know what the decimal\n// place is\n\n\n$.extend( DataTable.ext.type.search, {\n\thtml: function ( data ) {\n\t\treturn _empty(data) ?\n\t\t\tdata :\n\t\t\ttypeof data === 'string' ?\n\t\t\t\tdata\n\t\t\t\t\t.replace( _re_new_lines, \" \" )\n\t\t\t\t\t.replace( _re_html, \"\" ) :\n\t\t\t\t'';\n\t},\n\n\tstring: function ( data ) {\n\t\treturn _empty(data) ?\n\t\t\tdata :\n\t\t\ttypeof data === 'string' ?\n\t\t\t\tdata.replace( _re_new_lines, \" \" ) :\n\t\t\t\tdata;\n\t}\n} );\n\n\n\nvar __numericReplace = function ( d, decimalPlace, re1, re2 ) {\n\tif ( d !== 0 && (!d || d === '-') ) {\n\t\treturn -Infinity;\n\t}\n\t\n\tvar type = typeof d;\n\n\tif (type === 'number' || type === 'bigint') {\n\t\treturn d;\n\t}\n\n\t// If a decimal place other than `.` is used, it needs to be given to the\n\t// function so we can detect it and replace with a `.` which is the only\n\t// decimal place Javascript recognises - it is not locale aware.\n\tif ( decimalPlace ) {\n\t\td = _numToDecimal( d, decimalPlace );\n\t}\n\n\tif ( d.replace ) {\n\t\tif ( re1 ) {\n\t\t\td = d.replace( re1, '' );\n\t\t}\n\n\t\tif ( re2 ) {\n\t\t\td = d.replace( re2, '' );\n\t\t}\n\t}\n\n\treturn d * 1;\n};\n\n\n// Add the numeric 'deformatting' functions for sorting and search. This is done\n// in a function to provide an easy ability for the language options to add\n// additional methods if a non-period decimal place is used.\nfunction _addNumericSort ( decimalPlace ) {\n\t$.each(\n\t\t{\n\t\t\t// Plain numbers\n\t\t\t\"num\": function ( d ) {\n\t\t\t\treturn __numericReplace( d, decimalPlace );\n\t\t\t},\n\n\t\t\t// Formatted numbers\n\t\t\t\"num-fmt\": function ( d ) {\n\t\t\t\treturn __numericReplace( d, decimalPlace, _re_formatted_numeric );\n\t\t\t},\n\n\t\t\t// HTML numeric\n\t\t\t\"html-num\": function ( d ) {\n\t\t\t\treturn __numericReplace( d, decimalPlace, _re_html );\n\t\t\t},\n\n\t\t\t// HTML numeric, formatted\n\t\t\t\"html-num-fmt\": function ( d ) {\n\t\t\t\treturn __numericReplace( d, decimalPlace, _re_html, _re_formatted_numeric );\n\t\t\t}\n\t\t},\n\t\tfunction ( key, fn ) {\n\t\t\t// Add the ordering method\n\t\t\t_ext.type.order[ key+decimalPlace+'-pre' ] = fn;\n\n\t\t\t// For HTML types add a search formatter that will strip the HTML\n\t\t\tif ( key.match(/^html\\-/) ) {\n\t\t\t\t_ext.type.search[ key+decimalPlace ] = _ext.type.search.html;\n\t\t\t}\n\t\t}\n\t);\n}\n\n\n// Default sort methods\n$.extend( _ext.type.order, {\n\t// Dates\n\t\"date-pre\": function ( d ) {\n\t\tvar ts = Date.parse( d );\n\t\treturn isNaN(ts) ? -Infinity : ts;\n\t},\n\n\t// html\n\t\"html-pre\": function ( a ) {\n\t\treturn _empty(a) ?\n\t\t\t'' :\n\t\t\ta.replace ?\n\t\t\t\ta.replace( /<.*?>/g, \"\" ).toLowerCase() :\n\t\t\t\ta+'';\n\t},\n\n\t// string\n\t\"string-pre\": function ( a ) {\n\t\t// This is a little complex, but faster than always calling toString,\n\t\t// https://jsperf.com/tostring-v-check\n\t\treturn _empty(a) ?\n\t\t\t'' :\n\t\t\ttypeof a === 'string' ?\n\t\t\t\ta.toLowerCase() :\n\t\t\t\t! a.toString ?\n\t\t\t\t\t'' :\n\t\t\t\t\ta.toString();\n\t},\n\n\t// string-asc and -desc are retained only for compatibility with the old\n\t// sort methods\n\t\"string-asc\": function ( x, y ) {\n\t\treturn ((x < y) ? -1 : ((x > y) ? 1 : 0));\n\t},\n\n\t\"string-desc\": function ( x, y ) {\n\t\treturn ((x < y) ? 1 : ((x > y) ? -1 : 0));\n\t}\n} );\n\n\n// Numeric sorting types - order doesn't matter here\n_addNumericSort( '' );\n\n\n$.extend( true, DataTable.ext.renderer, {\n\theader: {\n\t\t_: function ( settings, cell, column, classes ) {\n\t\t\t// No additional mark-up required\n\t\t\t// Attach a sort listener to update on sort - note that using the\n\t\t\t// `DT` namespace will allow the event to be removed automatically\n\t\t\t// on destroy, while the `dt` namespaced event is the one we are\n\t\t\t// listening for\n\t\t\t$(settings.nTable).on( 'order.dt.DT', function ( e, ctx, sorting, columns ) {\n\t\t\t\tif ( settings !== ctx ) { // need to check this this is the host\n\t\t\t\t\treturn;               // table, not a nested one\n\t\t\t\t}\n\n\t\t\t\tvar colIdx = column.idx;\n\n\t\t\t\tcell\n\t\t\t\t\t.removeClass(\n\t\t\t\t\t\tclasses.sSortAsc +' '+\n\t\t\t\t\t\tclasses.sSortDesc\n\t\t\t\t\t)\n\t\t\t\t\t.addClass( columns[ colIdx ] == 'asc' ?\n\t\t\t\t\t\tclasses.sSortAsc : columns[ colIdx ] == 'desc' ?\n\t\t\t\t\t\t\tclasses.sSortDesc :\n\t\t\t\t\t\t\tcolumn.sSortingClass\n\t\t\t\t\t);\n\t\t\t} );\n\t\t},\n\n\t\tjqueryui: function ( settings, cell, column, classes ) {\n\t\t\t$('<div/>')\n\t\t\t\t.addClass( classes.sSortJUIWrapper )\n\t\t\t\t.append( cell.contents() )\n\t\t\t\t.append( $('<span/>')\n\t\t\t\t\t.addClass( classes.sSortIcon+' '+column.sSortingClassJUI )\n\t\t\t\t)\n\t\t\t\t.appendTo( cell );\n\n\t\t\t// Attach a sort listener to update on sort\n\t\t\t$(settings.nTable).on( 'order.dt.DT', function ( e, ctx, sorting, columns ) {\n\t\t\t\tif ( settings !== ctx ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tvar colIdx = column.idx;\n\n\t\t\t\tcell\n\t\t\t\t\t.removeClass( classes.sSortAsc +\" \"+classes.sSortDesc )\n\t\t\t\t\t.addClass( columns[ colIdx ] == 'asc' ?\n\t\t\t\t\t\tclasses.sSortAsc : columns[ colIdx ] == 'desc' ?\n\t\t\t\t\t\t\tclasses.sSortDesc :\n\t\t\t\t\t\t\tcolumn.sSortingClass\n\t\t\t\t\t);\n\n\t\t\t\tcell\n\t\t\t\t\t.find( 'span.'+classes.sSortIcon )\n\t\t\t\t\t.removeClass(\n\t\t\t\t\t\tclasses.sSortJUIAsc +\" \"+\n\t\t\t\t\t\tclasses.sSortJUIDesc +\" \"+\n\t\t\t\t\t\tclasses.sSortJUI +\" \"+\n\t\t\t\t\t\tclasses.sSortJUIAscAllowed +\" \"+\n\t\t\t\t\t\tclasses.sSortJUIDescAllowed\n\t\t\t\t\t)\n\t\t\t\t\t.addClass( columns[ colIdx ] == 'asc' ?\n\t\t\t\t\t\tclasses.sSortJUIAsc : columns[ colIdx ] == 'desc' ?\n\t\t\t\t\t\t\tclasses.sSortJUIDesc :\n\t\t\t\t\t\t\tcolumn.sSortingClassJUI\n\t\t\t\t\t);\n\t\t\t} );\n\t\t}\n\t}\n} );\n\n/*\n * Public helper functions. These aren't used internally by DataTables, or\n * called by any of the options passed into DataTables, but they can be used\n * externally by developers working with DataTables. They are helper functions\n * to make working with DataTables a little bit easier.\n */\n\nvar __htmlEscapeEntities = function ( d ) {\n\tif (Array.isArray(d)) {\n\t\td = d.join(',');\n\t}\n\n\treturn typeof d === 'string' ?\n\t\td\n\t\t\t.replace(/&/g, '&amp;')\n\t\t\t.replace(/</g, '&lt;')\n\t\t\t.replace(/>/g, '&gt;')\n\t\t\t.replace(/\"/g, '&quot;') :\n\t\td;\n};\n\n// Common logic for moment, luxon or a date action\nfunction __mld( dt, momentFn, luxonFn, dateFn, arg1 ) {\n\tif (window.moment) {\n\t\treturn dt[momentFn]( arg1 );\n\t}\n\telse if (window.luxon) {\n\t\treturn dt[luxonFn]( arg1 );\n\t}\n\t\n\treturn dateFn ? dt[dateFn]( arg1 ) : dt;\n}\n\n\nvar __mlWarning = false;\nfunction __mldObj (d, format, locale) {\n\tvar dt;\n\n\tif (window.moment) {\n\t\tdt = window.moment.utc( d, format, locale, true );\n\n\t\tif (! dt.isValid()) {\n\t\t\treturn null;\n\t\t}\n\t}\n\telse if (window.luxon) {\n\t\tdt = format && typeof d === 'string'\n\t\t\t? window.luxon.DateTime.fromFormat( d, format )\n\t\t\t: window.luxon.DateTime.fromISO( d );\n\n\t\tif (! dt.isValid) {\n\t\t\treturn null;\n\t\t}\n\n\t\tdt.setLocale(locale);\n\t}\n\telse if (! format) {\n\t\t// No format given, must be ISO\n\t\tdt = new Date(d);\n\t}\n\telse {\n\t\tif (! __mlWarning) {\n\t\t\talert('DataTables warning: Formatted date without Moment.js or Luxon - https://datatables.net/tn/17');\n\t\t}\n\n\t\t__mlWarning = true;\n\t}\n\n\treturn dt;\n}\n\n// Wrapper for date, datetime and time which all operate the same way with the exception of\n// the output string for auto locale support\nfunction __mlHelper (localeString) {\n\treturn function ( from, to, locale, def ) {\n\t\t// Luxon and Moment support\n\t\t// Argument shifting\n\t\tif ( arguments.length === 0 ) {\n\t\t\tlocale = 'en';\n\t\t\tto = null; // means toLocaleString\n\t\t\tfrom = null; // means iso8601\n\t\t}\n\t\telse if ( arguments.length === 1 ) {\n\t\t\tlocale = 'en';\n\t\t\tto = from;\n\t\t\tfrom = null;\n\t\t}\n\t\telse if ( arguments.length === 2 ) {\n\t\t\tlocale = to;\n\t\t\tto = from;\n\t\t\tfrom = null;\n\t\t}\n\n\t\tvar typeName = 'datetime-' + to;\n\n\t\t// Add type detection and sorting specific to this date format - we need to be able to identify\n\t\t// date type columns as such, rather than as numbers in extensions. Hence the need for this.\n\t\tif (! DataTable.ext.type.order[typeName]) {\n\t\t\t// The renderer will give the value to type detect as the type!\n\t\t\tDataTable.ext.type.detect.unshift(function (d) {\n\t\t\t\treturn d === typeName ? typeName : false;\n\t\t\t});\n\n\t\t\t// The renderer gives us Moment, Luxon or Date obects for the sorting, all of which have a\n\t\t\t// `valueOf` which gives milliseconds epoch\n\t\t\tDataTable.ext.type.order[typeName + '-asc'] = function (a, b) {\n\t\t\t\tvar x = a.valueOf();\n\t\t\t\tvar y = b.valueOf();\n\n\t\t\t\treturn x === y\n\t\t\t\t\t? 0\n\t\t\t\t\t: x < y\n\t\t\t\t\t\t? -1\n\t\t\t\t\t\t: 1;\n\t\t\t}\n\n\t\t\tDataTable.ext.type.order[typeName + '-desc'] = function (a, b) {\n\t\t\t\tvar x = a.valueOf();\n\t\t\t\tvar y = b.valueOf();\n\n\t\t\t\treturn x === y\n\t\t\t\t\t? 0\n\t\t\t\t\t: x > y\n\t\t\t\t\t\t? -1\n\t\t\t\t\t\t: 1;\n\t\t\t}\n\t\t}\n\t\n\t\treturn function ( d, type ) {\n\t\t\t// Allow for a default value\n\t\t\tif (d === null || d === undefined) {\n\t\t\t\tif (def === '--now') {\n\t\t\t\t\t// We treat everything as UTC further down, so no changes are\n\t\t\t\t\t// made, as such need to get the local date / time as if it were\n\t\t\t\t\t// UTC\n\t\t\t\t\tvar local = new Date();\n\t\t\t\t\td = new Date( Date.UTC(\n\t\t\t\t\t\tlocal.getFullYear(), local.getMonth(), local.getDate(),\n\t\t\t\t\t\tlocal.getHours(), local.getMinutes(), local.getSeconds()\n\t\t\t\t\t) );\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\td = '';\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (type === 'type') {\n\t\t\t\t// Typing uses the type name for fast matching\n\t\t\t\treturn typeName;\n\t\t\t}\n\n\t\t\tif (d === '') {\n\t\t\t\treturn type !== 'sort'\n\t\t\t\t\t? ''\n\t\t\t\t\t: __mldObj('0000-01-01 00:00:00', null, locale);\n\t\t\t}\n\n\t\t\t// Shortcut. If `from` and `to` are the same, we are using the renderer to\n\t\t\t// format for ordering, not display - its already in the display format.\n\t\t\tif ( to !== null && from === to && type !== 'sort' && type !== 'type' && ! (d instanceof Date) ) {\n\t\t\t\treturn d;\n\t\t\t}\n\n\t\t\tvar dt = __mldObj(d, from, locale);\n\n\t\t\tif (dt === null) {\n\t\t\t\treturn d;\n\t\t\t}\n\n\t\t\tif (type === 'sort') {\n\t\t\t\treturn dt;\n\t\t\t}\n\t\t\t\n\t\t\tvar formatted = to === null\n\t\t\t\t? __mld(dt, 'toDate', 'toJSDate', '')[localeString]()\n\t\t\t\t: __mld(dt, 'format', 'toFormat', 'toISOString', to);\n\n\t\t\t// XSS protection\n\t\t\treturn type === 'display' ?\n\t\t\t\t__htmlEscapeEntities( formatted ) :\n\t\t\t\tformatted;\n\t\t};\n\t}\n}\n\n// Based on locale, determine standard number formatting\n// Fallback for legacy browsers is US English\nvar __thousands = ',';\nvar __decimal = '.';\n\nif (window.Intl !== undefined) {\n\ttry {\n\t\tvar num = new Intl.NumberFormat().formatToParts(100000.1);\n\t\n\t\tfor (var i=0 ; i<num.length ; i++) {\n\t\t\tif (num[i].type === 'group') {\n\t\t\t\t__thousands = num[i].value;\n\t\t\t}\n\t\t\telse if (num[i].type === 'decimal') {\n\t\t\t\t__decimal = num[i].value;\n\t\t\t}\n\t\t}\n\t}\n\tcatch (e) {\n\t\t// noop\n\t}\n}\n\n// Formatted date time detection - use by declaring the formats you are going to use\nDataTable.datetime = function ( format, locale ) {\n\tvar typeName = 'datetime-detect-' + format;\n\n\tif (! locale) {\n\t\tlocale = 'en';\n\t}\n\n\tif (! DataTable.ext.type.order[typeName]) {\n\t\tDataTable.ext.type.detect.unshift(function (d) {\n\t\t\tvar dt = __mldObj(d, format, locale);\n\t\t\treturn d === '' || dt ? typeName : false;\n\t\t});\n\n\t\tDataTable.ext.type.order[typeName + '-pre'] = function (d) {\n\t\t\treturn __mldObj(d, format, locale) || 0;\n\t\t}\n\t}\n}\n\n/**\n * Helpers for `columns.render`.\n *\n * The options defined here can be used with the `columns.render` initialisation\n * option to provide a display renderer. The following functions are defined:\n *\n * * `number` - Will format numeric data (defined by `columns.data`) for\n *   display, retaining the original unformatted data for sorting and filtering.\n *   It takes 5 parameters:\n *   * `string` - Thousands grouping separator\n *   * `string` - Decimal point indicator\n *   * `integer` - Number of decimal points to show\n *   * `string` (optional) - Prefix.\n *   * `string` (optional) - Postfix (/suffix).\n * * `text` - Escape HTML to help prevent XSS attacks. It has no optional\n *   parameters.\n *\n * @example\n *   // Column definition using the number renderer\n *   {\n *     data: \"salary\",\n *     render: $.fn.dataTable.render.number( '\\'', '.', 0, '$' )\n *   }\n *\n * @namespace\n */\nDataTable.render = {\n\tdate: __mlHelper('toLocaleDateString'),\n\tdatetime: __mlHelper('toLocaleString'),\n\ttime: __mlHelper('toLocaleTimeString'),\n\tnumber: function ( thousands, decimal, precision, prefix, postfix ) {\n\t\t// Auto locale detection\n\t\tif (thousands === null || thousands === undefined) {\n\t\t\tthousands = __thousands;\n\t\t}\n\n\t\tif (decimal === null || decimal === undefined) {\n\t\t\tdecimal = __decimal;\n\t\t}\n\n\t\treturn {\n\t\t\tdisplay: function ( d ) {\n\t\t\t\tif ( typeof d !== 'number' && typeof d !== 'string' ) {\n\t\t\t\t\treturn d;\n\t\t\t\t}\n\n\t\t\t\tif (d === '' || d === null) {\n\t\t\t\t\treturn d;\n\t\t\t\t}\n\n\t\t\t\tvar negative = d < 0 ? '-' : '';\n\t\t\t\tvar flo = parseFloat( d );\n\n\t\t\t\t// If NaN then there isn't much formatting that we can do - just\n\t\t\t\t// return immediately, escaping any HTML (this was supposed to\n\t\t\t\t// be a number after all)\n\t\t\t\tif ( isNaN( flo ) ) {\n\t\t\t\t\treturn __htmlEscapeEntities( d );\n\t\t\t\t}\n\n\t\t\t\tflo = flo.toFixed( precision );\n\t\t\t\td = Math.abs( flo );\n\n\t\t\t\tvar intPart = parseInt( d, 10 );\n\t\t\t\tvar floatPart = precision ?\n\t\t\t\t\tdecimal+(d - intPart).toFixed( precision ).substring( 2 ):\n\t\t\t\t\t'';\n\n\t\t\t\t// If zero, then can't have a negative prefix\n\t\t\t\tif (intPart === 0 && parseFloat(floatPart) === 0) {\n\t\t\t\t\tnegative = '';\n\t\t\t\t}\n\n\t\t\t\treturn negative + (prefix||'') +\n\t\t\t\t\tintPart.toString().replace(\n\t\t\t\t\t\t/\\B(?=(\\d{3})+(?!\\d))/g, thousands\n\t\t\t\t\t) +\n\t\t\t\t\tfloatPart +\n\t\t\t\t\t(postfix||'');\n\t\t\t}\n\t\t};\n\t},\n\n\ttext: function () {\n\t\treturn {\n\t\t\tdisplay: __htmlEscapeEntities,\n\t\t\tfilter: __htmlEscapeEntities\n\t\t};\n\t}\n};\n\n\n/*\n * This is really a good bit rubbish this method of exposing the internal methods\n * publicly... - To be fixed in 2.0 using methods on the prototype\n */\n\n\n/**\n * Create a wrapper function for exporting an internal functions to an external API.\n *  @param {string} fn API function name\n *  @returns {function} wrapped function\n *  @memberof DataTable#internal\n */\nfunction _fnExternApiFunc (fn)\n{\n\treturn function() {\n\t\tvar args = [_fnSettingsFromNode( this[DataTable.ext.iApiIndex] )].concat(\n\t\t\tArray.prototype.slice.call(arguments)\n\t\t);\n\t\treturn DataTable.ext.internal[fn].apply( this, args );\n\t};\n}\n\n\n/**\n * Reference to internal functions for use by plug-in developers. Note that\n * these methods are references to internal functions and are considered to be\n * private. If you use these methods, be aware that they are liable to change\n * between versions.\n *  @namespace\n */\n$.extend( DataTable.ext.internal, {\n\t_fnExternApiFunc: _fnExternApiFunc,\n\t_fnBuildAjax: _fnBuildAjax,\n\t_fnAjaxUpdate: _fnAjaxUpdate,\n\t_fnAjaxParameters: _fnAjaxParameters,\n\t_fnAjaxUpdateDraw: _fnAjaxUpdateDraw,\n\t_fnAjaxDataSrc: _fnAjaxDataSrc,\n\t_fnAddColumn: _fnAddColumn,\n\t_fnColumnOptions: _fnColumnOptions,\n\t_fnAdjustColumnSizing: _fnAdjustColumnSizing,\n\t_fnVisibleToColumnIndex: _fnVisibleToColumnIndex,\n\t_fnColumnIndexToVisible: _fnColumnIndexToVisible,\n\t_fnVisbleColumns: _fnVisbleColumns,\n\t_fnGetColumns: _fnGetColumns,\n\t_fnColumnTypes: _fnColumnTypes,\n\t_fnApplyColumnDefs: _fnApplyColumnDefs,\n\t_fnHungarianMap: _fnHungarianMap,\n\t_fnCamelToHungarian: _fnCamelToHungarian,\n\t_fnLanguageCompat: _fnLanguageCompat,\n\t_fnBrowserDetect: _fnBrowserDetect,\n\t_fnAddData: _fnAddData,\n\t_fnAddTr: _fnAddTr,\n\t_fnNodeToDataIndex: _fnNodeToDataIndex,\n\t_fnNodeToColumnIndex: _fnNodeToColumnIndex,\n\t_fnGetCellData: _fnGetCellData,\n\t_fnSetCellData: _fnSetCellData,\n\t_fnSplitObjNotation: _fnSplitObjNotation,\n\t_fnGetObjectDataFn: _fnGetObjectDataFn,\n\t_fnSetObjectDataFn: _fnSetObjectDataFn,\n\t_fnGetDataMaster: _fnGetDataMaster,\n\t_fnClearTable: _fnClearTable,\n\t_fnDeleteIndex: _fnDeleteIndex,\n\t_fnInvalidate: _fnInvalidate,\n\t_fnGetRowElements: _fnGetRowElements,\n\t_fnCreateTr: _fnCreateTr,\n\t_fnBuildHead: _fnBuildHead,\n\t_fnDrawHead: _fnDrawHead,\n\t_fnDraw: _fnDraw,\n\t_fnReDraw: _fnReDraw,\n\t_fnAddOptionsHtml: _fnAddOptionsHtml,\n\t_fnDetectHeader: _fnDetectHeader,\n\t_fnGetUniqueThs: _fnGetUniqueThs,\n\t_fnFeatureHtmlFilter: _fnFeatureHtmlFilter,\n\t_fnFilterComplete: _fnFilterComplete,\n\t_fnFilterCustom: _fnFilterCustom,\n\t_fnFilterColumn: _fnFilterColumn,\n\t_fnFilter: _fnFilter,\n\t_fnFilterCreateSearch: _fnFilterCreateSearch,\n\t_fnEscapeRegex: _fnEscapeRegex,\n\t_fnFilterData: _fnFilterData,\n\t_fnFeatureHtmlInfo: _fnFeatureHtmlInfo,\n\t_fnUpdateInfo: _fnUpdateInfo,\n\t_fnInfoMacros: _fnInfoMacros,\n\t_fnInitialise: _fnInitialise,\n\t_fnInitComplete: _fnInitComplete,\n\t_fnLengthChange: _fnLengthChange,\n\t_fnFeatureHtmlLength: _fnFeatureHtmlLength,\n\t_fnFeatureHtmlPaginate: _fnFeatureHtmlPaginate,\n\t_fnPageChange: _fnPageChange,\n\t_fnFeatureHtmlProcessing: _fnFeatureHtmlProcessing,\n\t_fnProcessingDisplay: _fnProcessingDisplay,\n\t_fnFeatureHtmlTable: _fnFeatureHtmlTable,\n\t_fnScrollDraw: _fnScrollDraw,\n\t_fnApplyToChildren: _fnApplyToChildren,\n\t_fnCalculateColumnWidths: _fnCalculateColumnWidths,\n\t_fnThrottle: _fnThrottle,\n\t_fnConvertToWidth: _fnConvertToWidth,\n\t_fnGetWidestNode: _fnGetWidestNode,\n\t_fnGetMaxLenString: _fnGetMaxLenString,\n\t_fnStringToCss: _fnStringToCss,\n\t_fnSortFlatten: _fnSortFlatten,\n\t_fnSort: _fnSort,\n\t_fnSortAria: _fnSortAria,\n\t_fnSortListener: _fnSortListener,\n\t_fnSortAttachListener: _fnSortAttachListener,\n\t_fnSortingClasses: _fnSortingClasses,\n\t_fnSortData: _fnSortData,\n\t_fnSaveState: _fnSaveState,\n\t_fnLoadState: _fnLoadState,\n\t_fnImplementState: _fnImplementState,\n\t_fnSettingsFromNode: _fnSettingsFromNode,\n\t_fnLog: _fnLog,\n\t_fnMap: _fnMap,\n\t_fnBindAction: _fnBindAction,\n\t_fnCallbackReg: _fnCallbackReg,\n\t_fnCallbackFire: _fnCallbackFire,\n\t_fnLengthOverflow: _fnLengthOverflow,\n\t_fnRenderer: _fnRenderer,\n\t_fnDataSource: _fnDataSource,\n\t_fnRowAttributes: _fnRowAttributes,\n\t_fnExtend: _fnExtend,\n\t_fnCalculateEnd: function () {} // Used by a lot of plug-ins, but redundant\n\t                                // in 1.10, so this dead-end function is\n\t                                // added to prevent errors\n} );\n\n\n// jQuery access\n$.fn.dataTable = DataTable;\n\n// Provide access to the host jQuery object (circular reference)\nDataTable.$ = $;\n\n// Legacy aliases\n$.fn.dataTableSettings = DataTable.settings;\n$.fn.dataTableExt = DataTable.ext;\n\n// With a capital `D` we return a DataTables API instance rather than a\n// jQuery object\n$.fn.DataTable = function ( opts ) {\n\treturn $(this).dataTable( opts ).api();\n};\n\n// All properties that are available to $.fn.dataTable should also be\n// available on $.fn.DataTable\n$.each( DataTable, function ( prop, val ) {\n\t$.fn.DataTable[ prop ] = val;\n} );\n\nexport default DataTable;\n"],"names":["n","e","t","l","o","fn","dataTable","extend","ext","buttons","colvis","i","init","text","i18n","className","closeButton","columns","columnText","on","namespace","button","node","collectionRebuild","columnsToggle","indexes","map","toArray","columnToggle","columnsVisibility","visibility","columnVisibility","_columnText","action","visible","length","this","attr","bDestroying","nTable","settings","active","column","destroying","count","destroy","off","index","aoColumns","sTitle","header","innerHTML","replace","colvisRestore","_visOriginal","every","colReorder","transpose","colvisGroup","show","hide","adjust","window","document","C","T","y","k","S","JSZip","s","pdfMake","N","sheetName","u","c","exportData","exportOptions","fieldBoundary","r","fieldSeparator","a","RegExp","d","escapeChar","p","footer","f","body","push","str","join","rows","navigator","userAgent","indexOf","match","Buttons","jszip","O","m","test","URL","webkitURL","createElementNS","HTMLElement","safari","setImmediate","setTimeout","revokeObjectURL","remove","type","Blob","String","fromCharCode","split","concat","call","readyState","INIT","createObjectURL","href","download","MouseEvent","dispatchEvent","DONE","FileReader","onloadend","result","open","location","readAsDataURL","prototype","msSaveOrOpenBlob","name","abort","WRITING","error","onwritestart","onprogress","onwrite","onabort","onerror","onwriteend","self","content","fileSave","newline","z","charCodeAt","Math","floor","D","A","XMLSerializer","E","createElement","children","each","appendChild","createTextNode","_","R","style","fmt","round","Date","parse","copyHtml5","processing","exportInfo","css","height","width","overflow","position","top","left","title","messageTop","messageBottom","customize","val","appendTo","queryCommandSupported","table","container","focus","select","execCommand","info","append","closest","keyCode","csvHtml5","bom","available","charset","characterSet","filename","extension","excelHtml5","parseXML","createEmptyCells","trim","row","ref","parseFloat","getElementsByTagName","_rels","xl","worksheets","I","customizeData","F","x","h","b","prepend","g","v","min","max","toString","sort","customWidth","w","autoFilter","before","localSheetId","hidden","compression","mimeType","B","serializeToString","DOMParser","parseFromString","isPlainObject","folder","childNodes","attributes","nodeName","nodeValue","value","removeAttribute","createAttribute","setAttributeNode","file","substr","generateAsync","then","generate","pdfHtml5","pageSize","pageOrientation","orientation","headerRows","layout","styles","tableHeader","bold","fontSize","color","fillColor","alignment","tableBodyEven","tableBodyOdd","tableFooter","message","defaultStyle","unshift","margin","createPdf","$","defaults","dom","renderer","classes","sWrapper","sFilterInput","sLengthSelect","sProcessing","sPageButton","pageButton","bootstrap","host","idx","page","pages","btnDisplay","btnClass","activeEl","api","Api","oClasses","lang","oLanguage","oPaginate","aria","oAria","paginate","attach","ien","clickHandler","preventDefault","currentTarget","hasClass","data","draw","Array","isArray","sFirst","sPrevious","sNext","sLast","disabled","sTableId","iTabIndex","html","oApi","_fnBindAction","hostEl","find","activeElement","paginationEl","empty","addClass","undefined","trigger","collection","dropHtml","tag","spacer","dropdown","align","splitAlignClass","wrapper","buttonCreated","config","rightAlignClassName","_instCounter","_buttonCounter","_dtButtons","_fadeIn","el","duration","animate","stop","fadeIn","_fadeOut","fadeOut","_infoTimer","dt","listenKeys","_constructor","_nodeToButton","conf","flag","klass","jqNode","inCollection","toggleClass","add","base","_expandButton","_draw","newButtons","prefixButtons","apply","postfixButtons","newBtn","parentConf","disable","prop","slice","buttonInsts","inst","splice","enable","removeClass","nested","inner","triggerHandler","_nodeToHost","_removeKey","inArray","label","textNode","opt","that","dtSettings","_buttons","character","toLowerCase","_keypress","_addKey","key","detach","inserter","attachTo","inSplit","attachPoint","isSplit","domCollection","_resolveExtends","built","_buildButton","_collection","j","item","parent","collectionLayout","dropup","fade","configDom","hasOwnProperty","clickBlurs","id","liner","enabled","titleAttr","splitDiv","buttonContainer","dropdownConf","wrapperConf","dropButtonConfig","splitAction","dropButton","stopPropagation","get","ret","_buttonsHandled","run","click","shiftKey","altKey","ctrlKey","metaKey","recurse","toConfObject","loop","objArray","originalClassName","_popover","hostButton","inOpts","closed","options","autoClose","background","backgroundClassName","containerClassName","contentClassName","collectionTitle","popoverTitle","containerSelector","hostNode","close","nodes","existingExpanded","eq","cnt","mod","display","role","parents","lastChild","insertAfter","tableContainer","span","offsetParent","buttonPosition","buttonOffset","offset","tableSizes","containerPosition","computed","getComputedStyle","outerHeight","paddingLeft","right","bottom","popoverSizes","outerWidth","marginTop","marginBottom","scrollTop","half","backgroundHost","btn","back","addBack","target","filter","elements","first","last","insertPoint","instanceSelector","group","names","process","input","buttonSelector","insts","selector","nodeBuilder","baseIdx","stripData","stripHtml","stripNewlines","decodeEntities","_exportTextarea","tabIndex","version","popover","copy","csv","excel","pdf","pageLength","lengthMenu","aLengthMenu","vals","option","len","register","buttonGroup","res","iterator","ctx","_groupSelector","registerPlural","set","jq","groupSelector","containers","context","pluck","unique","time","clearTimeout","_exportData","_filename","_title","_message","_stringOrFunction","caption","modifier","search","order","orthogonal","format","selected","any","rowIndexes","selectedCells","cells","render","cellNodes","cellCounter","_init","opts","DataTable","oInit","feature","fnInit","cFeature","features","modal","_display","Responsive","_original","_modal","_bs","bs","Modal","update","closeCallback","contains","one","versionCheck","childNodeStore","current","responsive","details","dtPrivateSettings","oldWindowWidth","innerWidth","_responsive","util","throttle","_resize","_fnCallbackReg","tr","to$","_setColumnVis","breakpoints","_classLogic","_resizeAuto","_detailsInit","_timer","_redrawChildren","curr","rowIds","child","isShown","_detailsDisplay","_controlClass","_childNodes","col","cell","_childNodesRestore","parentChildren","parentNode","jen","_columnsVisiblity","breakpoint","columnIdx","priority","auto","minWidth","includeIn","requiredWidth","scrolling","oScroll","bar","sY","sX","iBarWidth","usedWidth","offsetWidth","control","colIdx","showControl","never","responsivePriority","dataPriority","getAttribute","operator","matched","size","_find","classNames","ken","brokenPoint","re","columnsVis","firstVisible","event","_detailsObj","_tabIndexes","targetIdx","rowIdx","dtCol","sClass","columnIndex","rowIndex","forceRedraw","oldVis","collapsedClass","changed","recordsDisplay","isEmptyObject","clonedTable","cloneNode","clonedHeader","clonedBody","clone","headerCells","clonedFooter","footerCells","removeAttr","inserted","clear","insertBefore","_responsiveOnlyHidden","showHide","removeData","Infinity","childRow","childRowImmediate","hasHidden","listHiddenNodes","ul","found","listHidden","tableAll","tableClass","li","json","RowGroup","rowGroup","existing","dataSrc","hostSettings","_adjustColspan","_colspan","reduce","groupedRows","_group","_groupDisplay","level","fns","_fnGetObjectDataFn","emptyDataGroup","dataPoint","groups","groupName","startRender","_rowWrap","startClassName","endRender","endClassName","_ext","_Api","_api_register","_api_registerPlural","factory","sSelector","oOpts","traditional","_fnSettingsFromNode","iApiIndex","fnAddData","redraw","flatten","fnAdjustColumnSizing","bRedraw","scroll","_fnScrollDraw","fnClearTable","fnClose","nTr","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","listener","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","rowId","_fnBrowserDetect","sTable","iInitDisplayStart","iDisplayStart","_iDisplayStart","iDeferLoading","bDeferLoading","tmp","_iRecordsDisplay","_iRecordsTotal","sUrl","ajax","dataType","url","success","_fnCallbackFire","_fnInitialise","asStripeClasses","sStripeOdd","sStripeEven","stripeClasses","rowOne","asDestroyStripes","aoColumnsInit","anThs","nThead","_fnDetectHeader","aoHeader","_fnGetUniqueThs","_fnAddColumn","_fnApplyColumnDefs","aoColumnDefs","oDef","_fnColumnOptions","_isArrayHost","loadedInit","aaSorting","sorting","asSorting","_fnSortingClasses","bSort","bSorted","aSort","_fnSortFlatten","sortedColumns","dir","_fnSortAria","_fnDataSource","bDeferRender","captions","_captionSide","thead","tbody","nTBody","tfoot","sNoFooter","aoFooter","aaData","_fnAddData","_fnAddTr","aiDisplay","aiDisplayMaster","bInitialised","_fnSaveState","bStateSave","_fnLoadState","_re_dic","_re_new_lines","_re_html","_re_date","_re_escape_regex","_re_formatted_numeric","_empty","_intVal","integer","parseInt","isNaN","isFinite","_numToDecimal","num","decimalPoint","_fnEscapeRegex","_isNumber","formatted","strType","_htmlNumeric","_isHtml","_stripHtml","_pluck","prop2","out","_pluck_order","_range","start","end","_removeEmpty","sorted","_areAllUnique","again","_flatten","_includes","_fnHungarianMap","newKey","_hungarianMap","user","force","hungarianKey","charAt","defaultDecimal","sDecimal","_addNumericSort","zeroRecords","sZeroRecords","sEmptyTable","sLoadingRecords","sInfoThousands","sThousands","decimal","arg","Object","includes","freq","timer","frequency","now","args","arguments","escapeRegex","source","meta","setData","arrayNotation","funcNotation","innerSrc","_fnSplitObjNotation","aLast","Error","__reArray","__reFn","jLen","fetchData","substring","_fnCompatMap","knew","old","sScrollX","scrollX","searchCols","aoSearchCols","oSearch","dataSort","aDataSort","__browser","browser","scrollLeft","outer","barWidth","clientWidth","bScrollOversize","bScrollbarLeft","bBounding","getBoundingClientRect","oBrowser","_fnReduce","inc","isSet","nTh","oDefaults","oCol","oColumn","aoPreSearchCols","oOptions","th","sWidthOrig","mDataProp","sType","_sManualType","origClass","iDataSort","ariaTitle","mDataSrc","mRender","attrTest","_bAttrSrc","_setter","rowData","innerData","fnSetData","_fnSetObjectDataFn","_rowReadObject","bSortable","sSortableNone","bAsc","bDesc","sSortingClass","sSortableAsc","sSortingClassJUI","sSortJUIAscAllowed","sSortableDesc","sSortJUIDescAllowed","sSortable","sSortJUI","_fnAdjustColumnSizing","bAutoWidth","_fnCalculateColumnWidths","sWidth","_fnVisibleToColumnIndex","iMatch","aiVis","_fnGetColumns","_fnColumnIndexToVisible","iPos","_fnVisbleColumns","vis","bVisible","sParam","_fnColumnTypes","detectedType","cache","types","detect","_fnGetCellData","aoColDefs","aoCols","kLen","def","aTargets","targets","aDataIn","anTds","oData","oRow","_aData","aIds","_fnCreateTr","trs","_fnGetRowElements","iDraw","defaultContent","sDefaultContent","cellData","iDrawError","fomatters","_fnSetCellData","_fnGetDataMaster","_fnClearTable","_fnDeleteIndex","iTarget","iTargetIndex","_fnInvalidate","cellWrite","removeChild","firstChild","anCells","_aSortData","_aFilterData","cols","_fnRowAttributes","contents","tds","td","objectRead","setter","cellProcess","nextSibling","rowNode","nTrIn","nTd","create","_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","ajaxComplete","bServerSide","fnRecordsDisplay","_fnStart","aPreDraw","anRows","iRowCount","iStripes","oLang","iDisplayEnd","fnDisplayEnd","bDrawing","_fnProcessingDisplay","_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","bPaginate","bLengthChange","_fnFeatureHtmlLength","_fnFeatureHtmlFilter","bProcessing","_fnFeatureHtmlProcessing","_fnFeatureHtmlTable","bInfo","_fnFeatureHtmlInfo","_fnFeatureHtmlPaginate","aoFeatures","aanFeatures","replaceWith","aLayout","nCell","iColShifted","bUnique","nTrs","fnShiftCol","nHeader","aReturn","bSortCellsTop","_fnBuildAjax","rbracket","ajaxData","instance","status","jqXHR","_fnAjaxDataSrc","sError","newData","baseAjax","sServerMethod","xhr","thrown","oAjaxData","fnServerData","sAjaxSource","drawHold","_fnAjaxParameters","_fnAjaxUpdateDraw","dataProp","columnSearch","columnCount","preSearch","preColSearch","displayStart","displayLength","_iDisplayLength","param","sSearch","regex","sName","searchable","bSearchable","orderable","legacy","compat","modern","recordsTotal","recordsFiltered","_bInitComplete","_fnInitComplete","write","sAjaxDataProp","tableId","language","previousSearch","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","__filter_div","__filter_div_textContent","textContent","filterData","wasInvalidated","innerText","_fnSearchToCamel","obj","_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","outerHTML","sPaginationType","plugin","pager","sPaging","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","headerWidths","footerWidths","headerContent","footerContent","zeroOut","nSizer","paddingTop","paddingBottom","borderTopWidth","borderBottomWidth","scrollBarVis","scrollHeight","clientHeight","prependTo","_fnApplyToChildren","offsetHeight","nToSize","iOuterWidth","bScrolling","padding","an1","an2","nNode1","nNode2","nodeType","__re_html_remove","visibleColumns","tableWidthAttr","userInputs","styleWidth","sizes","_fnConvertToWidth","tmpTable","_fnGetWidestNode","sContentPadding","holder","bounding","_reszEvt","bindResize","sInstance","widths","els","results","_fnGetMaxLenString","maxIdx","srcCol","fixed","aaSortingFixed","fixedObj","nestedSort","pre","post","_idx","sortCol","aiOrig","oExtSort","formatters","_fnSortData","dataA","dataB","nextSort","setAttribute","sSortAscending","sSortDescending","_fnSortListener","nextSortIdx","next","bSortMulti","sortIdx","oldSort","aLastSort","sortClass","sSortColumn","bSortClasses","customData","customSort","sSortDataType","_bLoadingState","state","oSavedState","fnStateSaveCallback","fnStateLoadCallback","_fnImplementState","abStateLoad","iStateDuration","oLoadedState","msg","tn","console","log","sErrMode","errMode","alert","mappedName","extender","breakRefs","which","sStore","callbackArr","eventName","reverse","Event","__apiStruct","__arrayProto","ctxSettings","mixed","tables","_toSettings","alwaysNew","items","apiInst","_selector_row_indexes","apiSelector","lastIndexOf","pop","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","stateSaveParamsEvent","destroyEvent","idFn","ids","_detailsShow","childRows","loaded","__details_state","__details_remove","_details","__details_display","__details_events","drawEvent","colvisEvent","_child_obj","_child_mth","addRow","created","colSpan","__details_add","__re_column_selector","__columnData","r1","r2","visColumns","jqResult","__column_selector","calc","__setColumnVis","rowSelector","columnSelector","allCells","fnSelector","__cell_selector","internalOpts","cellsNoOpts","caseInsen","use","module","DateTime","root","is","jquery","iThis","iThat","aThis","aThat","isDataTable","fnIsDataTable","head","foot","fnTables","camelToHungarian","jqRows","jqTable","jqTbody","jqWrapper","orig","removedMethod","sDestroyWidth","arg1","arg2","arg3","arg4","token","plural","resolved","toFormat","JSON","sessionStorage","localStorage","getItem","pathname","setItem","stringify","builder","oJUIClasses","sVersion","afnFiltering","aTypes","ofnSearch","oSort","afnSortData","oStdClasses","oPagination","extPagination","_numbers","numbers","numbers_length","DT_el","simple","full","simple_numbers","full_numbers","first_last_numbers","disabledClass","sPageButtonDisabled","sPageButtonActive","pagingTag","parsed","string","__numericReplace","decimalPlace","re1","re2","ts","sSortAsc","sSortDesc","jqueryui","sSortJUIWrapper","sSortIcon","sSortJUIAsc","sSortJUIDesc","__htmlEscapeEntities","__mld","momentFn","luxonFn","dateFn","moment","luxon","__mlWarning","__mldObj","locale","utc","isValid","fromFormat","fromISO","setLocale","__mlHelper","localeString","from","to","typeName","valueOf","local","UTC","getFullYear","getMonth","getDate","getHours","getMinutes","getSeconds","__thousands","__decimal","Intl","NumberFormat","formatToParts","datetime","date","number","thousands","precision","prefix","postfix","negative","flo","toFixed","abs","intPart","floatPart","_fnNodeToDataIndex","_fnNodeToColumnIndex","_fnCalculateEnd","dataTableSettings","dataTableExt"],"sourceRoot":""}