{"version":3,"file":"js/9566-bb5bf49054c81f4911b9.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/dataTables.mjs"],"sourcesContent":["/*!\n * Column visibility buttons for Buttons and DataTables.\n * © SpryMedia Ltd - datatables.net/license\n */\n!function(i){var o,e;\"function\"==typeof define&&define.amd?define([\"jquery\",\"datatables.net\",\"datatables.net-buttons\"],function(n){return i(n,window,document)}):\"object\"==typeof exports?(o=require(\"jquery\"),e=function(n,t){t.fn.dataTable||require(\"datatables.net\")(n,t),t.fn.dataTable.Buttons||require(\"datatables.net-buttons\")(n,t)},\"undefined\"==typeof window?module.exports=function(n,t){return n=n||window,t=t||o(n),e(n,t),i(t,0,n.document)}:(e(window,o),module.exports=i(o,window,window.document))):i(jQuery,window,document)}(function(n,t,i){\"use strict\";var e=n.fn.dataTable;return n.extend(e.ext.buttons,{colvis:function(n,t){var i=null,o={extend:\"collection\",init:function(n,t){i=t},text:function(n){return n.i18n(\"buttons.colvis\",\"Column visibility\")},className:\"buttons-colvis\",closeButton:!1,buttons:[{extend:\"columnsToggle\",columns:t.columns,columnText:t.columnText}]};return n.on(\"column-reorder.dt\"+t.namespace,function(){n.button(null,n.button(null,i).node()).collectionRebuild([{extend:\"columnsToggle\",columns:t.columns,columnText:t.columnText}])}),o},columnsToggle:function(n,t){return n.columns(t.columns).indexes().map(function(n){return{extend:\"columnToggle\",columns:n,columnText:t.columnText}}).toArray()},columnToggle:function(n,t){return{extend:\"columnVisibility\",columns:t.columns,columnText:t.columnText}},columnsVisibility:function(n,t){return n.columns(t.columns).indexes().map(function(n){return{extend:\"columnVisibility\",columns:n,visibility:t.visibility,columnText:t.columnText}}).toArray()},columnVisibility:{columns:void 0,text:function(n,t,i){return i._columnText(n,i)},className:\"buttons-columnVisibility\",action:function(n,t,i,o){var t=t.columns(o.columns),e=t.visible();t.visible(void 0!==o.visibility?o.visibility:!(e.length&&e[0]))},init:function(i,n,o){var e=this;n.attr(\"data-cv-idx\",o.columns),i.on(\"column-visibility.dt\"+o.namespace,function(n,t){t.bDestroying||t.nTable!=i.settings()[0].nTable||e.active(i.column(o.columns).visible())}).on(\"column-reorder.dt\"+o.namespace,function(){o.destroying||1===i.columns(o.columns).count()&&(e.text(o._columnText(i,o)),e.active(i.column(o.columns).visible()))}),this.active(i.column(o.columns).visible())},destroy:function(n,t,i){n.off(\"column-visibility.dt\"+i.namespace).off(\"column-reorder.dt\"+i.namespace)},_columnText:function(n,t){var i,o;return\"string\"==typeof t.text?t.text:(o=n.column(t.columns).title(),i=n.column(t.columns).index(),o=o.replace(/\\n/g,\" \").replace(/<br\\s*\\/?>/gi,\" \").replace(/<select(.*?)<\\/select\\s*>/gi,\"\"),o=e.Buttons.stripHtmlComments(o),o=e.util.stripHtml(o).trim(),t.columnText?t.columnText(n,i,o):o)}},colvisRestore:{className:\"buttons-colvisRestore\",text:function(n){return n.i18n(\"buttons.colvisRestore\",\"Restore visibility\")},init:function(n,t,i){n.columns().every(function(){var n=this.init();void 0===n.__visOriginal&&(n.__visOriginal=this.visible())})},action:function(n,t,i,o){t.columns().every(function(n){var t=this.init();this.visible(t.__visOriginal)})}},colvisGroup:{className:\"buttons-colvisGroup\",action:function(n,t,i,o){t.columns(o.show).visible(!0,!1),t.columns(o.hide).visible(!1,!1),t.columns.adjust()},show:[],hide:[]}}),e});","/*!\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(o){var l,n;\"function\"==typeof define&&define.amd?define([\"jquery\",\"datatables.net\",\"datatables.net-buttons\"],function(t){return o(t,window,document)}):\"object\"==typeof exports?(l=require(\"jquery\"),n=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){return t=t||window,e=e||l(t),n(t,e),o(e,t,t.document)}:(n(window,l),module.exports=o(l,window,window.document))):o(jQuery,window,document)}(function(S,C,u){\"use strict\";var e,o,t=S.fn.dataTable;function T(){return e||C.JSZip}function s(){return o||C.pdfMake}t.Buttons.pdfMake=function(t){if(!t)return s();o=t},t.Buttons.jszip=function(t){if(!t)return T();e=t};function k(t){var e=\"Sheet1\";return e=t.sheetName?t.sheetName.replace(/[\\[\\]\\*\\/\\\\\\?\\:]/g,\"\"):e}function c(t,e){function o(t){for(var e=\"\",o=0,l=t.length;o<l;o++)0<o&&(e+=a),e+=r?r+(\"\"+t[o]).replace(d,p+r)+r:t[o];return e}var l=y(e),n=t.buttons.exportData(e.exportOptions),r=e.fieldBoundary,a=e.fieldSeparator,d=new RegExp(r,\"g\"),p=void 0!==e.escapeChar?e.escapeChar:\"\\\\\",t=\"\",i=\"\",f=[];e.header&&(t=n.headerStructure.map(function(t){return o(t.map(function(t){return t?t.title:\"\"}))}).join(l)+l),e.footer&&n.footer&&(i=n.footerStructure.map(function(t){return o(t.map(function(t){return t?t.title:\"\"}))}).join(l)+l);for(var s=0,m=n.body.length;s<m;s++)f.push(o(n.body[s]));return{str:t+f.join(l)+l+i,rows:f.length}}function m(){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 N=function(d){var p,i,f,s,m,u,e,c,y,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\"),f=\"download\"in i,s=/constructor/i.test(d.HTMLElement)||d.safari,m=/CriOS\\/[\\d]+/.test(navigator.userAgent),u=function(t){(d.setImmediate||d.setTimeout)(function(){throw t},0)},e=4e4,c=function(t){setTimeout(function(){\"string\"==typeof t?p().revokeObjectURL(t):t.remove()},e)},y=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=y(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){u(t)}}};r.readyState=r.INIT,f?(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(),c(l),r.readyState=r.DONE})):(m||e&&s)&&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),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(),c(l))}).prototype,\"undefined\"!=typeof navigator&&navigator.msSaveOrOpenBlob?function(t,e,o){return e=e||t.name||\"download\",o||(t=y(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!==C&&C||this.content),y=(t.fileSave=N,function(t){return t.newline||(navigator.userAgent.match(/Windows/)?\"\\r\\n\":\"\\n\")});function O(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 z,E=new XMLSerializer}catch(t){}function A(t,e,o){var l=t.createElement(e);return o&&(o.attr&&S(l).attr(o.attr),o.children&&S.each(o.children,function(t,e){l.appendChild(e)}),null!==o.text)&&void 0!==o.text&&l.appendChild(t.createTextNode(o.text)),l}function D(t,e,o,l,n){var r=S(\"mergeCells\",t);r[0].appendChild(A(t,\"mergeCell\",{attr:{ref:O(o)+e+\":\"+O(o+n-1)+(e+l-1)}})),r.attr(\"count\",parseFloat(r.attr(\"count\"))+1)}var R={\"_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=\"[$$-409]#,##0.00;-[$$-409]#,##0.00\"/><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>'},_=[{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:/^(19\\d\\d|[2-9]\\d\\d\\d)\\-(0\\d|1[012])\\-[0123][\\d]$/,style:67,fmt:function(t){return Math.round(25569+Date.parse(t)/864e5)}}];return t.ext.buttons.copyHtml5={className:\"buttons-copy buttons-html5\",text:function(t){return t.i18n(\"buttons.copy\",\"Copy\")},action:function(t,e,o,l,n){var r=c(e,l),a=e.buttons.exportInfo(l),d=y(l),p=r.str,i=S(\"<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)),S(\"<textarea readonly/>\").val(p).appendTo(i));if(u.queryCommandSupported(\"copy\")){i.appendTo(e.table().container()),d[0].focus(),d[0].select();try{var f=u.execCommand(\"copy\");if(i.remove(),f)return l.copySuccess&&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 n()}catch(t){}}function s(){m.off(\"click.buttons-copy\"),S(u).off(\".buttons-copy\"),e.buttons.info(!1)}var a=S(\"<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(),S(a).closest(\".dt-button-info\"));m.on(\"click.buttons-copy\",function(){s(),n()}),S(u).on(\"keydown.buttons-copy\",function(t){27===t.keyCode&&(s(),n())}).on(\"copy.buttons-copy cut.buttons-copy\",function(){s(),n()})},async:100,copySuccess:!0,exportOptions:{},fieldSeparator:\"\\t\",fieldBoundary:\"\",header:!0,footer:!0,title:\"*\",messageTop:\"*\",messageBottom:\"*\"},t.ext.buttons.csvHtml5={bom:!1,className:\"buttons-csv buttons-html5\",available:function(){return void 0!==C.FileReader&&C.Blob},text:function(t){return t.i18n(\"buttons.csv\",\"CSV\")},action:function(t,e,o,l,n){var r=c(e,l).str,a=e.buttons.exportInfo(l),d=l.charset;l.customize&&(r=l.customize(r,l,e)),d=!1!==d?(d=d||u.characterSet||u.charset)&&\";charset=\"+d:\"\",l.bom&&(r=String.fromCharCode(65279)+r),N(new Blob([r],{type:\"text/csv\"+d}),a.filename,!0),n()},async:100,filename:\"*\",extension:\".csv\",exportOptions:{},fieldSeparator:\",\",fieldBoundary:'\"',escapeChar:'\"',charset:null,header:!0,footer:!0},t.ext.buttons.excelHtml5={className:\"buttons-excel buttons-html5\",available:function(){return void 0!==C.FileReader&&void 0!==T()&&!m()&&E},text:function(t){return t.i18n(\"buttons.excel\",\"Excel\")},action:function(t,e,o,f,l){function n(t){return t=R[t],S.parseXML(t)}function r(t){m=A(c,\"row\",{attr:{r:s=u+1}});for(var e=0,o=t.length;e<o;e++){var l=O(e)+\"\"+s,n=null;if(null===t[e]||void 0===t[e]||\"\"===t[e]){if(!0!==f.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=_.length;a<d;a++){var p=_[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=A(c,\"c\",{attr:{r:l,s:p.style},children:[A(c,\"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+/)?A(c,\"c\",{attr:{t:\"n\",r:l},children:[A(c,\"v\",{text:t[e]})]}):(r=r.replace?r.replace(/[\\x00-\\x09\\x0B\\x0C\\x0E-\\x1F\\x7F-\\x9F]/g,\"\"):r,A(c,\"c\",{attr:{t:\"inlineStr\",r:l},children:{row:A(c,\"is\",{children:{row:A(c,\"t\",{text:r,attr:{\"xml:space\":\"preserve\"}})}})}}))),m.appendChild(n)}y.appendChild(m),u++}function a(t){t.forEach(function(t){r(t.map(function(t){return t?t.title:\"\"})),S(\"row:last c\",c).attr(\"s\",\"2\"),t.forEach(function(t,e){t&&(1<t.colSpan||1<t.rowSpan)&&D(c,u,e,t.rowSpan,t.colSpan)})})}var d,s,m,u=0,c=n(\"xl/worksheets/sheet1.xml\"),y=c.getElementsByTagName(\"sheetData\")[0],p={_rels:{\".rels\":n(\"_rels/.rels\")},xl:{_rels:{\"workbook.xml.rels\":n(\"xl/_rels/workbook.xml.rels\")},\"workbook.xml\":n(\"xl/workbook.xml\"),\"styles.xml\":n(\"xl/styles.xml\"),worksheets:{\"sheet1.xml\":c}},\"[Content_Types].xml\":n(\"[Content_Types].xml\")},i=e.buttons.exportData(f.exportOptions),I=e.buttons.exportInfo(f);I.title&&(r([I.title]),D(c,u,0,1,i.header.length),S(\"row:last c\",c).attr(\"s\",\"51\")),I.messageTop&&(r([I.messageTop]),D(c,u,0,1,i.header.length)),f.header&&a(i.headerStructure);for(var F=u,x=0,h=i.body.length;x<h;x++)r(i.body[x]);d=u,f.footer&&i.footer&&a(i.footerStructure),I.messageBottom&&(r([I.messageBottom]),D(c,u,0,1,i.header.length));var b=A(c,\"cols\");S(\"worksheet\",c).prepend(b);for(var g=0,v=i.header.length;g<v;g++)b.appendChild(A(c,\"col\",{attr:{min:g+1,max:g+1,width:function(t,e){var o=t.header[e].length;t.footer&&t.footer[e]&&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.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\"];S(\"sheets sheet\",w).attr(\"name\",k(f)),f.autoFilter&&(S(\"mergeCells\",c).before(A(c,\"autoFilter\",{attr:{ref:\"A\"+F+\":\"+O(i.header.length-1)+d}})),S(\"definedNames\",w).append(A(w,\"definedName\",{attr:{name:\"_xlnm._FilterDatabase\",localSheetId:\"0\",hidden:1},text:\"'\"+k(f).replace(/'/g,\"''\")+\"'!$A$\"+F+\":\"+O(i.header.length-1)+d}))),f.customize&&f.customize(p,f,e),0===S(\"mergeCells\",c).children().length&&S(\"mergeCells\",c).remove();var w=new(T()),F={compression:\"DEFLATE\",type:\"blob\",mimeType:\"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet\"},B=(!function f(s,t){void 0===z&&(z=-1===E.serializeToString((new C.DOMParser).parseFromString(R[\"xl/worksheets/sheet1.xml\"],\"text/xml\")).indexOf(\"xmlns:r\")),S.each(t,function(t,e){if(S.isPlainObject(e))f(s.folder(t),e);else{if(z){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=E.serializeToString(e),i=(i=z?(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>\");s.file(t,i)}})}(w,p),I.filename);175<B&&(B=B.substr(0,175)),f.customizeZip&&f.customizeZip(w,i,B),w.generateAsync?w.generateAsync(F).then(function(t){N(t,B),l()}):(N(w.generate(F),B),l())},async:100,filename:\"*\",extension:\".xlsx\",exportOptions:{},header:!0,footer:!0,title:\"*\",messageTop:\"*\",messageBottom:\"*\",createEmptyCells:!1,autoFilter:!1,sheetName:\"\"},t.ext.buttons.pdfHtml5={className:\"buttons-pdf buttons-html5\",available:function(){return void 0!==C.FileReader&&s()},text:function(t){return t.i18n(\"buttons.pdf\",\"PDF\")},action:function(t,e,o,l,n){var r=e.buttons.exportData(l.exportOptions),a=e.buttons.exportInfo(l),d=[];l.header&&r.headerStructure.forEach(function(t){d.push(t.map(function(t){return t?{text:t.title,colSpan:t.colspan,rowSpan:t.rowspan,style:\"tableHeader\"}:{}}))});for(var p=0,i=r.body.length;p<i;p++)d.push(r.body[p].map(function(t){return{text:null==t?\"\":\"string\"==typeof t?t:t.toString()}}));l.footer&&r.footerStructure.forEach(function(t){d.push(t.map(function(t){return t?{text:t.title,colSpan:t.colspan,rowSpan:t.rowspan,style:\"tableHeader\"}:{}}))});var f={pageSize:l.pageSize,pageOrientation:l.orientation,content:[{style:\"table\",table:{headerRows:r.headerStructure.length,footerRows:r.footerStructure.length,body:d},layout:{hLineWidth:function(t,e){return 0===t||t===e.table.body.length?0:.5},vLineWidth:function(){return 0},hLineColor:function(t,e){return t===e.table.headerRows||t===e.table.body.length-e.table.footerRows?\"#333\":\"#ddd\"},fillColor:function(t){return t<r.headerStructure.length?\"#fff\":t%2==0?\"#f3f3f3\":null},paddingTop:function(){return 5},paddingBottom:function(){return 5}}}],styles:{tableHeader:{bold:!0,fontSize:11,alignment:\"center\"},tableFooter:{bold:!0,fontSize:11},table:{margin:[0,5,0,5]},title:{alignment:\"center\",fontSize:13},message:{}},defaultStyle:{fontSize:10}},e=(a.messageTop&&f.content.unshift({text:a.messageTop,style:\"message\",margin:[0,0,0,12]}),a.messageBottom&&f.content.push({text:a.messageBottom,style:\"message\",margin:[0,0,0,12]}),a.title&&f.content.unshift({text:a.title,style:\"title\",margin:[0,0,0,12]}),l.customize&&l.customize(f,l,e),s().createPdf(f));\"open\"!==l.download||m()?e.download(a.filename):e.open(),n()},async:100,title:\"*\",filename:\"*\",extension:\".pdf\",exportOptions:{},orientation:\"portrait\",pageSize:\"en-US\"===navigator.language||\"en-CA\"===navigator.language?\"LETTER\":\"A4\",header:!0,footer:!0,messageTop:\"*\",messageBottom:\"*\",customize:null,download:\"download\"},t});","/*! DataTables Bootstrap 5 integration\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 * DataTables integration for Bootstrap 5.\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\trenderer: 'bootstrap'\n} );\n\n\n/* Default class modification */\n$.extend( true, DataTable.ext.classes, {\n\tcontainer: \"dt-container dt-bootstrap5\",\n\tsearch: {\n\t\tinput: \"form-control form-control-sm\"\n\t},\n\tlength: {\n\t\tselect: \"form-select form-select-sm\"\n\t},\n\tprocessing: {\n\t\tcontainer: \"dt-processing card\"\n\t},\n\tlayout: {\n\t\trow: 'row mt-2 justify-content-between',\n\t\tcell: 'd-md-flex justify-content-between align-items-center',\n\t\ttableCell: 'col-12',\n\t\tstart: 'dt-layout-start col-md-auto me-auto',\n\t\tend: 'dt-layout-end col-md-auto ms-auto',\n\t\tfull: 'dt-layout-full col-md'\n\t}\n} );\n\n\n/* Bootstrap paging button renderer */\nDataTable.ext.renderer.pagingButton.bootstrap = function (settings, buttonType, content, active, disabled) {\n\tvar btnClasses = ['dt-paging-button', 'page-item'];\n\n\tif (active) {\n\t\tbtnClasses.push('active');\n\t}\n\n\tif (disabled) {\n\t\tbtnClasses.push('disabled')\n\t}\n\n\tvar li = $('<li>').addClass(btnClasses.join(' '));\n\tvar a = $('<button>', {\n\t\t'class': 'page-link',\n\t\trole: 'link',\n\t\ttype: 'button'\n\t})\n\t\t.html(content)\n\t\t.appendTo(li);\n\n\treturn {\n\t\tdisplay: li,\n\t\tclicker: a\n\t};\n};\n\nDataTable.ext.renderer.pagingContainer.bootstrap = function (settings, buttonEls) {\n\treturn $('<ul/>').addClass('pagination').append(buttonEls);\n};\n\n// DataTable.ext.renderer.layout.bootstrap = function ( settings, container, items ) {\n// \tvar row = $( '<div/>', {\n// \t\t\t\"class\": items.full ?\n// \t\t\t\t'row mt-2 justify-content-md-center' :\n// \t\t\t\t'row mt-2 justify-content-between'\n// \t\t} )\n// \t\t.appendTo( container );\n\n// \t$.each( items, function (key, val) {\n// \t\tvar klass;\n// \t\tvar cellClass = '';\n\n// \t\t// Apply start / end (left / right when ltr) margins\n// \t\tif (val.table) {\n// \t\t\tklass = 'col-12';\n// \t\t}\n// \t\telse if (key === 'start') {\n// \t\t\tklass = '' + cellClass;\n// \t\t}\n// \t\telse if (key === 'end') {\n// \t\t\tklass = '' + cellClass;\n// \t\t}\n// \t\telse {\n// \t\t\tklass = ' ' + cellClass;\n// \t\t}\n\n// \t\t$( '<div/>', {\n// \t\t\t\tid: val.id || null,\n// \t\t\t\t\"class\": klass + ' ' + (val.className || '')\n// \t\t\t} )\n// \t\t\t.append( val.contents )\n// \t\t\t.appendTo( row );\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 3.1.2\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// Custom entity decoder for data export\nvar _entityDecoder = null;\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\tif (!DataTable.versionCheck('2')) {\n\t\tthrow 'Warning: Buttons requires DataTables 2 or newer';\n\t}\n\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(\n\t\t\tthis.c.dom.container.className\n\t\t)\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 ||\n\t\t\t\tconfig.split === undefined ||\n\t\t\t\tconfig.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 &&\n\t\t\t\t\t\tnewBtn.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)\n\t\t\t.addClass(this.c.dom.button.disabled)\n\t\t\t.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)\n\t\t\t.removeClass(this.c.dom.button.disabled)\n\t\t\t.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'\n\t\t\t\t? opt(dt, jqNode, button.conf)\n\t\t\t\t: 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 (\n\t\t\t\t!document.activeElement ||\n\t\t\t\tdocument.activeElement === document.body\n\t\t\t) {\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)\n\t\t\t\t? conf.key.key\n\t\t\t\t: 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\n\t\t\t\t\t\t? built.conf.split\n\t\t\t\t\t\t: 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 &&\n\t\t\t\t\t\tconf.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 = $(\n\t\t\t\t\t'<' + domCollection.container.content.tag + '/>'\n\t\t\t\t);\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 that = this;\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(\n\t\t\t\t\t'dt-button-spacer ' +\n\t\t\t\t\t\tconfig.style +\n\t\t\t\t\t\t' ' +\n\t\t\t\t\t\tdom.spacer.className\n\t\t\t\t)\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 (\n\t\t\tconfig.available &&\n\t\t\t!config.available(dt, config) &&\n\t\t\t!config.html\n\t\t) {\n\t\t\treturn false;\n\t\t}\n\n\t\tvar button;\n\n\t\tif (!config.html) {\n\t\t\tvar run = function (e, dt, button, config, done) {\n\t\t\t\tconfig.action.call(dt.button(button), e, dt, button, config, done);\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 action = function(e, dt, button, config) {\n\t\t\t\tif (config.async) {\n\t\t\t\t\tthat.processing(button[0], true);\n\n\t\t\t\t\tsetTimeout(function () {\n\t\t\t\t\t\trun(e, dt, button, config, function () {\n\t\t\t\t\t\t\tthat.processing(button[0], false);\n\t\t\t\t\t\t});\n\t\t\t\t\t}, config.async);\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\trun(e, dt, button, config, function () {});\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tvar tag = config.tag || dom.tag;\n\t\t\tvar clickBlurs =\n\t\t\t\tconfig.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(\n\t\t\t\t\tdt.button(splitDiv),\n\t\t\t\t\te,\n\t\t\t\t\tdt,\n\t\t\t\t\tbutton,\n\t\t\t\t\tconfig\n\t\t\t\t);\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=\"' +\n\t\t\t\t\tdropdownConf.dropdown.className +\n\t\t\t\t\t' 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) {\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 =\n\t\t\toptions.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$(\n\t\t\t\tdt\n\t\t\t\t\t.buttons('[aria-haspopup=\"dialog\"][aria-expanded=\"true\"]')\n\t\t\t\t\t.nodes()\n\t\t\t).attr('aria-expanded', 'false');\n\n\t\t\t$('div.dt-button-background').off('click.dtb-collection');\n\t\t\tButtons.background(\n\t\t\t\tfalse,\n\t\t\t\toptions.backgroundClassName,\n\t\t\t\toptions.fade,\n\t\t\t\thostNode\n\t\t\t);\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\">' +\n\t\t\t\t\toptions.popoverTitle +\n\t\t\t\t\t'</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\">' +\n\t\t\t\t\toptions.collectionTitle +\n\t\t\t\t\t'</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 =\n\t\t\t\toffsetParent.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 (\n\t\t\t\toptions.align === 'button-right' ||\n\t\t\t\tdisplay.hasClass(options.rightAlignClassName)\n\t\t\t) {\n\t\t\t\tleft =\n\t\t\t\t\tbuttonPosition.left -\n\t\t\t\t\tpopoverSizes.width +\n\t\t\t\t\thostNode.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 (\n\t\t\t\toptions.align === 'dt-container' ||\n\t\t\t\toptions.align === 'container'\n\t\t\t) {\n\t\t\t\tif (left < buttonPosition.left) {\n\t\t\t\t\tleft = -buttonPosition.left;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Window adjustment\n\t\t\tif (\n\t\t\t\tcontainerPosition.left + left + popoverSizes.width >\n\t\t\t\t$(window).width()\n\t\t\t) {\n\t\t\t\t// Overflowing the document to the right\n\t\t\t\tleft =\n\t\t\t\t\t$(window).width() -\n\t\t\t\t\tpopoverSizes.width -\n\t\t\t\t\tcontainerPosition.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 place = 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\tplace();\n\n\t\t\t$(window).on('resize.dtb-collection', function () {\n\t\t\t\tplace();\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(\n\t\t\t'click.dtb-collection',\n\t\t\tfunction () {}\n\t\t);\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)\n\t\t\t\t\t\t\t.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/>')\n\t\t\t\t.addClass(className)\n\t\t\t\t.css('display', 'none')\n\t\t\t\t.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' && input.nodeName) {\n\t\t\t// Element selector\n\t\t\tfor (var j = 0; j < buttons.length; j++) {\n\t\t\t\tif (buttons[j].inst.dom.container[0] === input) {\n\t\t\t\t\tret.push(buttons[j].inst);\n\t\t\t\t}\n\t\t\t}\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 = Buttons.stripHtmlScript(str);\n\n\t// Always remove comments\n\tstr = Buttons.stripHtmlComments(str);\n\n\tif (!config || config.stripHtml) {\n\t\tstr = DataTable.util.stripHtml(str);\n\t}\n\n\tif (!config || config.trim) {\n\t\tstr = str.trim();\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\tif (_entityDecoder) {\n\t\t\tstr = _entityDecoder(str);\n\t\t}\n\t\telse {\n\t\t\t_exportTextarea.innerHTML = str;\n\t\t\tstr = _exportTextarea.value;\n\t\t}\n\t}\n\n\treturn str;\n};\n\n/**\n * Provide a custom entity decoding function - e.g. a regex one, which can be\n * much faster than the built in DOM option, but also larger code size.\n * @param {function} fn\n */\nButtons.entityDecoder = function (fn) {\n\t_entityDecoder = fn;\n};\n\n/**\n * Common function for stripping HTML comments\n *\n * @param {*} input \n * @returns \n */\nButtons.stripHtmlComments = function (input) {\n\tvar previous;  \n\t\n\tdo {  \n\t\tprevious = input;\n\t\tinput = input.replace(/(<!--.*?--!?>)|(<!--[\\S\\s]+?--!?>)|(<!--[\\S\\s]*?$)/g, '');\n\t} while (input !== previous);  \n\n\treturn input;  \n};\n\n/**\n * Common function for stripping HTML script tags\n *\n * @param {*} input \n * @returns \n */\nButtons.stripHtmlScript = function (input) {\n\tvar previous;  \n\t\n\tdo {  \n\t\tprevious = input;\n\t\tinput = input.replace(/<script\\b[^<]*(?:(?!<\\/script[^>]*>)<[^<]*)*<\\/script[^>]*>/gi, '');\n\t} while (input !== previous);  \n\n\treturn input;  \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 = '3.1.2';\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) {\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) {\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 () {\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 (\n\t\t\t_dtButtons.excelHtml5 &&\n\t\t\t_dtButtons.excelHtml5.available(dt, conf)\n\t\t) {\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(\n\t'buttons().active()',\n\t'button().active()',\n\tfunction (flag) {\n\t\tif (flag === undefined) {\n\t\t\treturn this.map(function (set) {\n\t\t\t\treturn set.inst.active(set.node);\n\t\t\t});\n\t\t}\n\n\t\treturn this.each(function (set) {\n\t\t\tset.inst.active(set.node, flag);\n\t\t});\n\t}\n);\n\n// Get / set button action\nDataTable.Api.registerPlural(\n\t'buttons().action()',\n\t'button().action()',\n\tfunction (action) {\n\t\tif (action === undefined) {\n\t\t\treturn this.map(function (set) {\n\t\t\t\treturn set.inst.action(set.node);\n\t\t\t});\n\t\t}\n\n\t\treturn this.each(function (set) {\n\t\t\tset.inst.action(set.node, action);\n\t\t});\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(\n\t['buttons().enable()', 'button().enable()'],\n\tfunction (flag) {\n\t\treturn this.each(function (set) {\n\t\t\tset.inst.enable(set.node, flag);\n\t\t});\n\t}\n);\n\n// Disable buttons\nDataTable.Api.register(\n\t['buttons().disable()', 'button().disable()'],\n\tfunction () {\n\t\treturn this.each(function (set) {\n\t\t\tset.inst.disable(set.node);\n\t\t});\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(\n\t'buttons().nodes()',\n\t'button().node()',\n\tfunction () {\n\t\tvar jq = $();\n\n\t\t// jQuery will automatically reduce duplicates to a single entry\n\t\t$(\n\t\t\tthis.each(function (set) {\n\t\t\t\tjq = jq.add(set.inst.node(set.node));\n\t\t\t})\n\t\t);\n\n\t\treturn jq;\n\t}\n);\n\n// Get / set button processing state\nDataTable.Api.registerPlural(\n\t'buttons().processing()',\n\t'button().processing()',\n\tfunction (flag) {\n\t\tif (flag === undefined) {\n\t\t\treturn this.map(function (set) {\n\t\t\t\treturn set.inst.processing(set.node);\n\t\t\t});\n\t\t}\n\n\t\treturn this.each(function (set) {\n\t\t\tset.inst.processing(set.node, flag);\n\t\t});\n\t}\n);\n\n// Get / set button text (i.e. the button labels)\nDataTable.Api.registerPlural(\n\t'buttons().text()',\n\t'button().text()',\n\tfunction (label) {\n\t\tif (label === undefined) {\n\t\t\treturn this.map(function (set) {\n\t\t\t\treturn set.inst.text(set.node);\n\t\t\t});\n\t\t}\n\n\t\treturn this.each(function (set) {\n\t\t\tset.inst.text(set.node, label);\n\t\t});\n\t}\n);\n\n// Trigger a button's action\nDataTable.Api.registerPlural(\n\t'buttons().trigger()',\n\t'button().trigger()',\n\tfunction () {\n\t\treturn this.each(function (set) {\n\t\t\tset.inst.node(set.node).trigger('click');\n\t\t});\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(\n\t\t\tthis._groupSelector,\n\t\t\tctx[0]._buttons\n\t\t);\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(\n\t'buttons().remove()',\n\t'buttons().remove()',\n\tfunction () {\n\t\tthis.each(function (set) {\n\t\t\tset.inst.remove(set.node);\n\t\t});\n\n\t\treturn this;\n\t}\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(\n\t\t\t\t$('<div/>')[typeof message === 'string' ? 'html' : 'append'](\n\t\t\t\t\tmessage\n\t\t\t\t)\n\t\t\t)\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, this),\n\t\ttitle: _title(conf, this),\n\t\tmessageTop: _message(this, conf, conf.message || conf.messageTop, 'top'),\n\t\tmessageBottom: _message(this, conf, conf.messageBottom, 'bottom')\n\t};\n});\n\n/**\n * Get the file name for an exported file.\n *\n * @param {object} config Button configuration\n * @param {object} dt DataTable instance\n */\nvar _filename = function (config, dt) {\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(config, dt);\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(/\\*/g, $('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, config, dt);\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, config, dt) {\n\tif (option === null || option === undefined) {\n\t\treturn null;\n\t}\n\telse if (typeof option === 'function') {\n\t\treturn option(config, dt);\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, dt) {\n\tvar title = _stringOrFunction(config.title, config, dt);\n\n\treturn title === null\n\t\t? null\n\t\t: title.indexOf('*') !== -1\n\t\t? title.replace(/\\*/g, $('head > title').text() || 'Exported data')\n\t\t: title;\n};\n\nvar _message = function (dt, config, option, position) {\n\tvar message = _stringOrFunction(option, config, dt);\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\tcustomizeZip: 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 col = dt.column(idx);\n\t\t\treturn config.format.header(col.title(), idx, col.header());\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\tvar val = '';\n\n\t\t\t\t\tif (el) {\n\t\t\t\t\t\tvar inner = $('.dt-column-title', el);\n\n\t\t\t\t\t\tval = inner.length\n\t\t\t\t\t\t\t? inner.html()\n\t\t\t\t\t\t\t: $(el).html();\n\t\t\t\t\t}\n\n\t\t\t\t\treturn config.format.footer(val, 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 (\n\t\tdt.select &&\n\t\ttypeof dt.select.info === 'function' &&\n\t\tmodifier.selected === undefined\n\t) {\n\t\tif (\n\t\t\tdt.rows(config.rows, $.extend({ selected: true }, modifier)).any()\n\t\t) {\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\t\torder: modifier.order\n\t});\n\tvar cells = selectedCells.render(config.orthogonal).toArray();\n\tvar cellNodes = selectedCells.nodes().toArray();\n\tvar cellIndexes = selectedCells.indexes().toArray();\n\n\tvar columns = dt.columns(config.columns).count();\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(\n\t\t\t\tcells[cellCounter],\n\t\t\t\tcellIndexes[cellCounter].row,\n\t\t\t\tcellIndexes[cellCounter].column,\n\t\t\t\tcellNodes[cellCounter]\n\t\t\t);\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\theaderStructure: _headerFormatter(\n\t\t\tconfig.format.header,\n\t\t\tdt.table().header.structure(config.columns)\n\t\t),\n\t\tfooter: footer,\n\t\tfooterStructure: _headerFormatter(\n\t\t\tconfig.format.footer,\n\t\t\tdt.table().footer.structure(config.columns)\n\t\t),\n\t\tbody: body\n\t};\n\n\tif (config.customizeData) {\n\t\tconfig.customizeData(data);\n\t}\n\n\treturn data;\n};\n\nfunction _headerFormatter(formatter, struct) {\n\tfor (var i=0 ; i<struct.length ; i++) {\n\t\tfor (var j=0 ; j<struct[i].length ; j++) {\n\t\t\tvar item = struct[i][j];\n\n\t\t\tif (item) {\n\t\t\t\titem.title = formatter(\n\t\t\t\t\titem.title,\n\t\t\t\t\tj,\n\t\t\t\t\titem.cell\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n\n\treturn struct;\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\n\t\t? options\n\t\t: api.init().buttons || DataTable.defaults.buttons;\n\n\treturn new Buttons(api, opts).container();\n}\n\n// DataTables 1 `dom` feature option\nDataTable.ext.feature.push({\n\tfnInit: _init,\n\tcFeature: 'B'\n});\n\n// DataTables 2 layout feature\nif (DataTable.feature) {\n\tDataTable.feature.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 && _bs.Modal) {\n\t\tmodal = new _bs.Modal(_modal[0]);\n\t}\n\n\treturn function (row, update, render, closeCallback) {\n\t\tif (! modal) {\n\t\t\treturn _original(row, update, render, closeCallback);\n\t\t}\n\t\telse {\n\t\t\tvar rendered = render();\n\n\t\t\tif (rendered === false) {\n\t\t\t\treturn false;\n\t\t\t}\n\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(rendered);\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\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(rendered);\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 3.0.3\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     3.0.3\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('2')) {\n\t\tthrow 'DataTables Responsive requires DataTables 2 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(\n\t\ttrue,\n\t\t{},\n\t\tResponsive.defaults,\n\t\tDataTable.defaults.responsive,\n\t\topts\n\t);\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 oldWindowWidth = $(window).innerWidth();\n\n\t\tdt.settings()[0]._responsive = this;\n\n\t\t// Use DataTables' throttle function to avoid processor thrashing\n\t\t$(window).on(\n\t\t\t'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// Handle new rows being dynamically added - needed as responsive\n\t\t// updates all rows (shown or not) a responsive change, rather than\n\t\t// per draw.\n\t\tdt.on('row-created.dtr', function (e, tr, data, idx) {\n\t\t\tif ($.inArray(false, that.s.current) !== -1) {\n\t\t\t\t$('>td, >th', tr).each(function (i) {\n\t\t\t\t\tvar idx = dt.column.index('toData', i);\n\n\t\t\t\t\tif (that.s.current[idx] === false) {\n\t\t\t\t\t\t$(this)\n\t\t\t\t\t\t\t.css('display', 'none')\n\t\t\t\t\t\t\t.addClass('dtr-hidden');\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\t\t\t$(dt.table().node()).removeClass('dtr-inline collapsed');\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\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\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\t// First pass when the table is ready\n\t\tdt\n\t\t\t.on('draw.dtr', function () {\n\t\t\t\tthat._controlClass();\n\t\t\t})\n\t\t\t.ready(function () {\n\t\t\t\tthat._resizeAuto();\n\t\t\t\tthat._resize();\n\n\t\t\t\t// Attach listeners after first pass\n\t\t\t\tdt.on('column-reorder.dtr', function (e, settings, details) {\n\t\t\t\t\tthat._classLogic();\n\t\t\t\t\tthat._resizeAuto();\n\t\t\t\t\tthat._resize(true);\n\t\t\t\t});\n\n\t\t\t\t// Change in column sizes means we need to calc\n\t\t\t\tdt.on('column-sizing.dtr', function () {\n\t\t\t\t\tthat._resizeAuto();\n\t\t\t\t\tthat._resize();\n\t\t\t\t});\n\t\t\t});\n\t},\n\n\t/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n\t * Private methods\n\t */\n\n\t/**\n\t * Insert a `col` tag into the correct location in a `colgroup`.\n\t *\n\t * @param {jQuery} colGroup The `colgroup` tag\n\t * @param {jQuery} colEl The `col` tag\n\t */\n\t_colGroupAttach: function (colGroup, colEls, idx) {\n\t\tvar found = null;\n\n\t\t// No need to do anything if already attached\n\t\tif (colEls[idx].get(0).parentNode === colGroup[0]) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Find the first `col` after our own which is already attached\n\t\tfor (var i = idx+1; i < colEls.length; i++) {\n\t\t\tif (colGroup[0] === colEls[i].get(0).parentNode) {\n\t\t\t\tfound = i;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\tif (found !== null) {\n\t\t\t// Insert before\n\t\t\tcolEls[idx].insertBefore(colEls[found][0]);\n\t\t}\n\t\telse {\n\t\t\t// If wasn't found, insert at the end\n\t\t\tcolGroup.append(colEls[idx]);\n\t\t}\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\tif (store.length > 0) {\n\t\t\tvar parent = store[0].parentNode;\n\t\t\tvar parentChildren = parent.childNodes;\n\t\t\tvar a = [];\n\n\t\t\tfor (var i = 0, ien = parentChildren.length; i < ien; i++) {\n\t\t\t\ta.push(parentChildren[i]);\n\t\t\t}\n\n\t\t\tfor (var j = 0, jen = a.length; j < jen; j++) {\n\t\t\t\tnode.appendChild(a[j]);\n\t\t\t}\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 (\n\t\t\t\tdisplay[colIdx] === '-' &&\n\t\t\t\t!columns[colIdx].control &&\n\t\t\t\tcolumns[colIdx].minWidth\n\t\t\t) {\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 (\n\t\t\t\t!columns[i].control &&\n\t\t\t\t!columns[i].never &&\n\t\t\t\tdisplay[i] === false\n\t\t\t) {\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 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 = column.init().responsivePriority;\n\t\t\t\tvar dataPriority = column\n\t\t\t\t\t.header()\n\t\t\t\t\t.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 (\n\t\t\t\t\tclassName === 'none' ||\n\t\t\t\t\tclassName === 'dtr-none' ||\n\t\t\t\t\tcol.never\n\t\t\t\t) {\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 (\n\t\t\t\t\tclassName === 'control' ||\n\t\t\t\t\tclassName === 'dtr-control'\n\t\t\t\t) {\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\\\\-)?(' +\n\t\t\t\t\t\t\tbrokenPoint[0] +\n\t\t\t\t\t\t\t')(\\\\-[_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 (\n\t\t\t\t\t\t\tmatch[2] === brokenPoint[0] &&\n\t\t\t\t\t\t\tmatch[3] === '-' + brokenPoint[1]\n\t\t\t\t\t\t) {\n\t\t\t\t\t\t\t// Class name matches breakpoint name fully\n\t\t\t\t\t\t\tcolumn(\n\t\t\t\t\t\t\t\ti,\n\t\t\t\t\t\t\t\tbreakpoint.name,\n\t\t\t\t\t\t\t\tmatch[1],\n\t\t\t\t\t\t\t\tmatch[2] + match[3]\n\t\t\t\t\t\t\t);\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' })\n\t\t\t\t.nodes()\n\t\t\t\t.to$()\n\t\t\t\t.addClass('dtr-control');\n\t\t}\n\t},\n\n\t/**\n\t * Show the details for the child row\n\t *\n\t * @param  {DataTables.Api} row    API instance for the row\n\t * @param  {boolean}        update Update flag\n\t * @private\n\t */\n\t_detailsDisplay: function (row, update) {\n\t\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('dtr-expanded', res !== false);\n\t\t\t$(dt.table().node()).triggerHandler('responsive-display.dt', [\n\t\t\t\tdt,\n\t\t\t\trow,\n\t\t\t\tres,\n\t\t\t\tupdate\n\t\t\t]);\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(\n\t\t\t\t\t\tthat,\n\t\t\t\t\t\tdt,\n\t\t\t\t\t\trow[0][0],\n\t\t\t\t\t\tthat._detailsObj(row[0])\n\t\t\t\t\t);\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(\n\t\t\t\t'click.dtr mousedown.dtr mouseup.dtr',\n\t\t\t\tselector,\n\t\t\t\tfunction (e) {\n\t\t\t\t\t// If the table is not collapsed (i.e. there is no hidden columns)\n\t\t\t\t\t// then take no action\n\t\t\t\t\tif (!$(dt.table().node()).hasClass('collapsed')) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Check that the row is actually a DataTable's controlled node\n\t\t\t\t\tif (\n\t\t\t\t\t\t$.inArray(\n\t\t\t\t\t\t\t$(this).closest('tr').get(0),\n\t\t\t\t\t\t\tdt.rows().nodes().toArray()\n\t\t\t\t\t\t) === -1\n\t\t\t\t\t) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\n\t\t\t\t\t// For column index, we determine if we should act or not in the\n\t\t\t\t\t// handler - otherwise it is already okay\n\t\t\t\t\tif (typeof target === 'number') {\n\t\t\t\t\t\tvar targetIdx =\n\t\t\t\t\t\t\ttarget < 0\n\t\t\t\t\t\t\t\t? dt.columns().eq(0).length + target\n\t\t\t\t\t\t\t\t: target;\n\n\t\t\t\t\t\tif (dt.cell(this).index().column !== targetIdx) {\n\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// $().closest() includes itself in its check\n\t\t\t\t\tvar row = dt.row($(this).closest('tr'));\n\n\t\t\t\t\t// Check event type to do an action\n\t\t\t\t\tif (e.type === 'click') {\n\t\t\t\t\t\t// The renderer is given as a function so the caller can execute it\n\t\t\t\t\t\t// only when they need (i.e. if hiding there is no point is running\n\t\t\t\t\t\t// the renderer)\n\t\t\t\t\t\tthat._detailsDisplay(row, false);\n\t\t\t\t\t}\n\t\t\t\t\telse if (e.type === 'mousedown') {\n\t\t\t\t\t\t// For mouse users, prevent the focus ring from showing\n\t\t\t\t\t\t$(this).css('outline', 'none');\n\t\t\t\t\t}\n\t\t\t\t\telse if (e.type === 'mouseup') {\n\t\t\t\t\t\t// And then re-allow at the end of the click\n\t\t\t\t\t\t$(this).trigger('blur').css('outline', '');\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\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: dt.column(i).title()\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\t\tvar dtSettings = dt.settings()[0];\n\t\tvar colGroup = $(dt.table().node()).children('colgroup');\n\t\tvar colEls = dtSettings.aoColumns.map(function (col) {\n\t\t\treturn col.colEl;\n\t\t});\n\n\t\tdt.columns()\n\t\t\t.eq(0)\n\t\t\t.each(function (colIdx, i) {\n\t\t\t\t// Do nothing on DataTables' hidden column - DT removes it from the table\n\t\t\t\t// so we need to slide back\n\t\t\t\tif (! dt.column(colIdx).visible()) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\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\n\t\t\t\t// DataTables 2 uses `col` to define the width for a column\n\t\t\t\t// and this needs to run each time, as DataTables will change\n\t\t\t\t// the column width. We may need to reattach if we've removed\n\t\t\t\t// an element previously.\n\t\t\t\tif (! columnsVis[i]) {\n\t\t\t\t\tcolEls[i].detach();\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tthat._colGroupAttach(colGroup, colEls, i);\n\t\t\t\t}\n\t\t\t});\n\n\t\tif (changed) {\n\t\t\tdt.columns.adjust();\n\n\t\t\tthis._redrawChildren();\n\n\t\t\t// Inform listeners of the change\n\t\t\t$(dt.table().node()).trigger('responsive-resize.dt', [\n\t\t\t\tdt,\n\t\t\t\tthis._responsiveOnlyHidden()\n\t\t\t]);\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\t\tvar visibleColumns = dt\n\t\t\t.columns()\n\t\t\t.indexes()\n\t\t\t.filter(function (idx) {\n\t\t\t\treturn dt.column(idx).visible();\n\t\t\t});\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// Clone the table with the current data in it\n\t\tvar clonedTable = dt.table().node().cloneNode(false);\n\t\tvar clonedHeader = $(dt.table().header().cloneNode(false)).appendTo(\n\t\t\tclonedTable\n\t\t);\n\t\tvar clonedFooter = $(dt.table().footer().cloneNode(false)).appendTo(\n\t\t\tclonedTable\n\t\t);\n\t\tvar clonedBody = $(dt.table().body())\n\t\t\t.clone(false, false)\n\t\t\t.empty()\n\t\t\t.appendTo(clonedTable); // use jQuery because of IE8\n\n\t\tclonedTable.style.width = 'auto';\n\n\t\t// Header\n\t\tdt.table()\n\t\t\t.header.structure(visibleColumns)\n\t\t\t.forEach((row) => {\n\t\t\t\tvar cells = row\n\t\t\t\t\t.filter(function (el) {\n\t\t\t\t\t\treturn el ? true : false;\n\t\t\t\t\t})\n\t\t\t\t\t.map(function (el) {\n\t\t\t\t\t\treturn $(el.cell)\n\t\t\t\t\t\t\t.clone(false)\n\t\t\t\t\t\t\t.css('display', 'table-cell')\n\t\t\t\t\t\t\t.css('width', 'auto')\n\t\t\t\t\t\t\t.css('min-width', 0);\n\t\t\t\t\t});\n\n\t\t\t\t$('<tr/>').append(cells).appendTo(clonedHeader);\n\t\t\t});\n\n\t\t// Always need an empty row that we can read widths from\n\t\tvar emptyRow = $('<tr/>').appendTo(clonedBody);\n\n\t\tfor (var i = 0; i < visibleColumns.count(); i++) {\n\t\t\temptyRow.append('<td/>');\n\t\t}\n\n\t\t// Body rows\n\t\tif (this.c.details.renderer._responsiveMovesNodes) {\n\t\t\t// Slow but it allows for moving elements around the document\n\t\t\tdt.rows({ page: 'current' }).every(function (rowIdx) {\n\t\t\t\tvar node = this.node();\n\n\t\t\t\tif (! node) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\t// We clone the table's rows and cells to create the sizing table\n\t\t\t\tvar tr = node.cloneNode(false);\n\n\t\t\t\tdt.cells(rowIdx, visibleColumns).every(function (rowIdx2, colIdx) {\n\t\t\t\t\t// If nodes have been moved out (listHiddenNodes), we need to\n\t\t\t\t\t// clone from the store\n\t\t\t\t\tvar store = that.s.childNodeStore[rowIdx + '-' + colIdx];\n\n\t\t\t\t\tif (store) {\n\t\t\t\t\t\t$(this.node().cloneNode(false))\n\t\t\t\t\t\t\t.append($(store).clone())\n\t\t\t\t\t\t\t.appendTo(tr);\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\t$(this.node()).clone(false).appendTo(tr);\n\t\t\t\t\t}\n\t\t\t\t});\n\n\t\t\t\tclonedBody.append(tr);\n\t\t\t});\n\t\t}\n\t\telse {\n\t\t\t// This is much faster, but it doesn't account for moving nodes around\n\t\t\t$(clonedBody)\n\t\t\t\t.append( $(dt.rows( { page: 'current' } ).nodes()).clone( false ) )\n\t\t\t\t.find( 'th, td' ).css( 'display', '' );\n\t\t}\n\n\t\t// Any cells which were hidden by Responsive in the host table, need to\n\t\t// be visible here for the calculations\n\t\tclonedBody.find('th, td').css('display', '');\n\n\t\t// Footer\n\t\tdt.table()\n\t\t\t.footer.structure(visibleColumns)\n\t\t\t.forEach((row) => {\n\t\t\t\tvar cells = row\n\t\t\t\t\t.filter(function (el) {\n\t\t\t\t\t\treturn el ? true : false;\n\t\t\t\t\t})\n\t\t\t\t\t.map(function (el) {\n\t\t\t\t\t\treturn $(el.cell)\n\t\t\t\t\t\t\t.clone(false)\n\t\t\t\t\t\t\t.css('display', 'table-cell')\n\t\t\t\t\t\t\t.css('width', 'auto')\n\t\t\t\t\t\t\t.css('min-width', 0);\n\t\t\t\t\t});\n\n\t\t\t\t$('<tr/>').append(cells).appendTo(clonedFooter);\n\t\t\t});\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 table now contains the smallest that each column can be\n\t\temptyRow.children().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\tthis._setHeaderVis(col, showHide, dt.table().header.structure());\n\t\tthis._setHeaderVis(col, showHide, dt.table().footer.structure());\n\n\t\tdt.column(col)\n\t\t\t.nodes()\n\t\t\t.to$()\n\t\t\t.css('display', display)\n\t\t\t.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 * Set the a column's visibility, taking into account multiple rows\n\t * in a header / footer and colspan attributes\n\t * @param {*} col\n\t * @param {*} showHide\n\t * @param {*} structure\n\t */\n\t_setHeaderVis: function (col, showHide, structure) {\n\t\tvar that = this;\n\t\tvar display = showHide ? '' : 'none';\n\n\t\tstructure.forEach(function (row) {\n\t\t\tif (row[col]) {\n\t\t\t\t$(row[col].cell)\n\t\t\t\t\t.css('display', display)\n\t\t\t\t\t.toggleClass('dtr-hidden', !showHide);\n\t\t\t}\n\t\t\telse {\n\t\t\t\t// In a colspan - need to rewind calc the new span since\n\t\t\t\t// display:none elements do not count as being spanned over\n\t\t\t\tvar search = col;\n\n\t\t\t\twhile (search >= 0) {\n\t\t\t\t\tif (row[search]) {\n\t\t\t\t\t\trow[search].cell.colSpan = that._colspan(row, search);\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\n\t\t\t\t\tsearch--;\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t},\n\n\t/**\n\t * How many columns should this cell span\n\t *\n\t * @param {*} row Header structure row\n\t * @param {*} idx The column index of the cell to span\n\t */\n\t_colspan: function (row, idx) {\n\t\tvar colspan = 1;\n\n\t\tfor (var col = idx + 1; col < row.length; col++) {\n\t\t\tif (row[col] === null && this.s.current[col]) {\n\t\t\t\t// colspan and not hidden by Responsive\n\t\t\t\tcolspan++;\n\t\t\t}\n\t\t\telse if (row[col]) {\n\t\t\t\t// Got the next cell, jump out\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\treturn colspan;\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\tvar rowNode = $(row.node());\n\n\t\tif (update) {\n\t\t\tif (rowNode.hasClass('dtr-expanded')) {\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 (!rowNode.hasClass('dtr-expanded')) {\n\t\t\t\tvar rendered = render();\n\n\t\t\t\tif (rendered === false) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\n\t\t\t\trow.child(rendered, 'child').show();\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\tvar rowNode = $(row.node());\n\n\t\tif (\n\t\t\t(!update && rowNode.hasClass('dtr-expanded')) ||\n\t\t\t!row.responsive.hasHidden()\n\t\t) {\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\tvar rendered = render();\n\n\t\t\tif (rendered === false) {\n\t\t\t\treturn false;\n\t\t\t}\n\n\t\t\trow.child(rendered, '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\tvar modal;\n\t\t\tvar rendered = render();\n\n\t\t\tif (rendered === false) {\n\t\t\t\treturn false;\n\t\t\t}\n\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('dtr-expanded');\n\n\t\t\t\t\tcloseCallback();\n\t\t\t\t};\n\n\t\t\t\tmodal = $('<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(rendered)\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$(\n\t\t\t\t\t\t\t\t\t'<div class=\"dtr-modal-close\">&times;</div>'\n\t\t\t\t\t\t\t\t).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(\n\t\t\t\t\t\t\tfunction () {\n\t\t\t\t\t\t\t\tclose();\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t)\n\t\t\t\t\t)\n\t\t\t\t\t.appendTo('body');\n\n\t\t\t\t$(row.node()).addClass('dtr-expanded');\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\tmodal = $('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(rendered);\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(\n\t\t\t\t\t'<h2>' + options.header(row) + '</h2>'\n\t\t\t\t);\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\tvar fn = function (api, rowIdx, columns) {\n\t\t\tvar that = this;\n\t\t\tvar ul = $(\n\t\t\t\t'<ul data-dtr-index=\"' + rowIdx + '\" class=\"dtr-details\"/>'\n\t\t\t);\n\t\t\tvar found = false;\n\n\t\t\t$.each(columns, function (i, col) {\n\t\t\t\tif (col.hidden) {\n\t\t\t\t\tvar klass = col.className\n\t\t\t\t\t\t? 'class=\"' + col.className + '\"'\n\t\t\t\t\t\t: '';\n\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(\n\t\t\t\t\t\t\t\t\tapi,\n\t\t\t\t\t\t\t\t\tcol.rowIndex,\n\t\t\t\t\t\t\t\t\tcol.columnIndex\n\t\t\t\t\t\t\t\t)\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\n\t\tfn._responsiveMovesNodes = true;\n\n\t\treturn fn;\n\t},\n\n\tlistHidden: function () {\n\t\treturn function (api, rowIdx, columns) {\n\t\t\tvar data = $.map(columns, function (col) {\n\t\t\t\tvar klass = col.className\n\t\t\t\t\t? 'class=\"' + col.className + '\"'\n\t\t\t\t\t: '';\n\n\t\t\t\treturn col.hidden\n\t\t\t\t\t? '<li ' +\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? $(\n\t\t\t\t\t\t'<ul data-dtr-index=\"' +\n\t\t\t\t\t\t\trowIdx +\n\t\t\t\t\t\t\t'\" class=\"dtr-details\"/>'\n\t\t\t\t).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\n\t\t\t\t\t? 'class=\"' + col.className + '\"'\n\t\t\t\t\t: '';\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 $(\n\t\t\t\t'<table class=\"' +\n\t\t\t\t\toptions.tableClass +\n\t\t\t\t\t' dtr-details\" width=\"100%\"/>'\n\t\t\t).append(data);\n\t\t};\n\t}\n};\n\n/**\n * Responsive default settings for initialisation\n *\n * @namespace\n * @name Responsive.defaults\n * @static\n */\nResponsive.defaults = {\n\t/**\n\t * List of breakpoints for the instance. Note that this means that each\n\t * instance can have its own breakpoints. Additionally, the breakpoints\n\t * cannot be changed once an instance has been creased.\n\t *\n\t * @type {Array}\n\t * @default Takes the value of `Responsive.breakpoints`\n\t */\n\tbreakpoints: Responsive.breakpoints,\n\n\t/**\n\t * Enable / disable auto hiding calculations. It can help to increase\n\t * performance slightly if you disable this option, but all columns would\n\t * need to have breakpoint classes assigned to them\n\t *\n\t * @type {Boolean}\n\t * @default  `true`\n\t */\n\tauto: true,\n\n\t/**\n\t * Details control. If given as a string value, the `type` property of the\n\t * default object is set to that value, and the defaults used for the rest\n\t * of the object - this is for ease of implementation.\n\t *\n\t * The object consists of the following properties:\n\t *\n\t * * `display` - A function that is used to show and hide the hidden details\n\t * * `renderer` - function that is called for display of the child row data.\n\t *   The default function will show the data from the hidden columns\n\t * * `target` - Used as the selector for what objects to attach the child\n\t *   open / close to\n\t * * `type` - `false` to disable the details display, `inline` or `column`\n\t *   for the two control types\n\t *\n\t * @type {Object|string}\n\t */\n\tdetails: {\n\t\tdisplay: Responsive.display.childRow,\n\n\t\trenderer: Responsive.renderer.listHidden(),\n\n\t\ttarget: 0,\n\n\t\ttype: 'inline'\n\t},\n\n\t/**\n\t * Orthogonal data request option. This is used to define the data type\n\t * requested when Responsive gets the data to show in the child row.\n\t *\n\t * @type {String}\n\t */\n\torthogonal: 'display'\n};\n\n/*\n * 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(\n\t'columns().responsiveHidden()',\n\t'column().responsiveHidden()',\n\tfunction () {\n\t\treturn this.iterator(\n\t\t\t'column',\n\t\t\tfunction (settings, column) {\n\t\t\t\treturn settings._responsive\n\t\t\t\t\t? settings._responsive._responsiveOnlyHidden()[column]\n\t\t\t\t\t: false;\n\t\t\t},\n\t\t\t1\n\t\t);\n\t}\n);\n\n/**\n * Version information\n *\n * @name Responsive.version\n * @static\n */\nResponsive.version = '3.0.3';\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.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     RowGroup\n * @description RowGrouping for DataTables\n * @version     1.5.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.11')) {\n\t\tthrow 'RowGroup requires DataTables 1.11 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('th:visible, 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.util.get(fns[level]);\n\t\tvar dt = this.s.dt;\n\t\tvar group, last;\n\t\tvar i, ien;\n\t\tvar data = [];\n\t\tvar that = this;\n\n\t\tfor (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\n\t\t\tgroup = fn(rowData, level);\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 (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.5.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 2.1.5\n * © 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\tvar _that = this;\n\tvar emptyInit = options === undefined;\n\tvar len = this.length;\n\n\tif ( emptyInit ) {\n\t\toptions = {};\n\t}\n\n\t// Method to get DT API instance from jQuery object\n\tthis.api = function ()\n\t{\n\t\treturn new _Api( this );\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\n\t\tvar i=0, iLen;\n\t\tvar sId = this.getAttribute( 'id' );\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$(this).trigger( 'options.dt', oInit );\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\tnew DataTable.Api(s).destroy();\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\tcolgroup: $('<colgroup>').prependTo(this),\n\t\t\tfastData: function (row, column, type) {\n\t\t\t\treturn _fnGetCellData(oSettings, row, column, type);\n\t\t\t}\n\t\t} );\n\t\toSettings.nTable = this;\n\t\toSettings.oInit  = oInit;\n\t\t\n\t\tallSettings.push( oSettings );\n\t\t\n\t\t// Make a single API instance available for internal handling\n\t\toSettings.api = new _Api( 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\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\t? oInit.aLengthMenu[0][0]\n\t\t\t\t: $.isPlainObject( oInit.aLengthMenu[0] )\n\t\t\t\t\t? oInit.aLengthMenu[0].value\n\t\t\t\t\t: 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\"ajax\",\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\"iStateDuration\",\n\t\t\t\"bSortCellsTop\",\n\t\t\t\"iTabIndex\",\n\t\t\t\"sDom\",\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\"caption\",\n\t\t\t\"layout\",\n\t\t\t\"orderDescReverse\",\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 );\n\t\t_fnCallbackReg( oSettings, 'aoStateSaveParams',    oInit.fnStateSaveParams );\n\t\t_fnCallbackReg( oSettings, 'aoStateLoadParams',    oInit.fnStateLoadParams );\n\t\t_fnCallbackReg( oSettings, 'aoStateLoaded',        oInit.fnStateLoaded );\n\t\t_fnCallbackReg( oSettings, 'aoRowCallback',        oInit.fnRowCallback );\n\t\t_fnCallbackReg( oSettings, 'aoRowCreatedCallback', oInit.fnCreatedRow );\n\t\t_fnCallbackReg( oSettings, 'aoHeaderCallback',     oInit.fnHeaderCallback );\n\t\t_fnCallbackReg( oSettings, 'aoFooterCallback',     oInit.fnFooterCallback );\n\t\t_fnCallbackReg( oSettings, 'aoInitComplete',       oInit.fnInitComplete );\n\t\t_fnCallbackReg( oSettings, 'aoPreDrawCallback',    oInit.fnPreDrawCallback );\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.table );\n\t\t\n\t\tif (! oSettings.oFeatures.bPaginate) {\n\t\t\toInit.iDisplayStart = 0;\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\tvar defer = oInit.iDeferLoading;\n\t\tif ( defer !== null )\n\t\t{\n\t\t\toSettings.deferLoading = true;\n\t\t\n\t\t\tvar tmp = Array.isArray(defer);\n\t\t\toSettings._iRecordsDisplay = tmp ? defer[0] : defer;\n\t\t\toSettings._iRecordsTotal = tmp ? defer[1] : defer;\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 columnsInit = [];\n\t\tvar thead = this.getElementsByTagName('thead');\n\t\tvar initHeaderLayout = _fnDetectHeader( oSettings, thead[0] );\n\t\t\n\t\t// If we don't have a columns array, then generate one with nulls\n\t\tif ( oInit.aoColumns ) {\n\t\t\tcolumnsInit = oInit.aoColumns;\n\t\t}\n\t\telse if ( initHeaderLayout.length ) {\n\t\t\tfor ( i=0, iLen=initHeaderLayout[0].length ; i<iLen ; i++ ) {\n\t\t\t\tcolumnsInit.push( null );\n\t\t\t}\n\t\t}\n\t\t\n\t\t// Add the columns\n\t\tfor ( i=0, iLen=columnsInit.length ; i<iLen ; i++ ) {\n\t\t\t_fnAddColumn( oSettings );\n\t\t}\n\t\t\n\t\t// Apply the column definitions\n\t\t_fnApplyColumnDefs( oSettings, oInit.aoColumnDefs, columnsInit, initHeaderLayout, 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\tvar rowOne = $this.children('tbody').find('tr').eq(0);\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\t// Must be done after everything which can be overridden by the state saving!\n\t\t_fnCallbackReg( oSettings, 'aoDrawCallback', _fnSaveState );\n\t\t\n\t\tvar features = oSettings.oFeatures;\n\t\tif ( oInit.bStateSave )\n\t\t{\n\t\t\tfeatures.bStateSave = true;\n\t\t}\n\t\t\n\t\t// If aaSorting is not defined, then we use the first indicator in asSorting\n\t\t// in case that has been altered, so the default sort reflects that option\n\t\tif ( oInit.aaSorting === undefined ) {\n\t\t\tvar sorting = oSettings.aaSorting;\n\t\t\tfor ( i=0, iLen=sorting.length ; i<iLen ; i++ ) {\n\t\t\t\tsorting[i][1] = oSettings.aoColumns[ i ].asSorting[0];\n\t\t\t}\n\t\t}\n\t\t\n\t\t// Do a first pass on the sorting classes (allows any size changes to be taken into\n\t\t// account, and also will apply sorting disabled classes if disabled\n\t\t_fnSortingClasses( oSettings );\n\t\t\n\t\t_fnCallbackReg( oSettings, 'aoDrawCallback', function () {\n\t\t\tif ( oSettings.bSorted || _fnDataSource( oSettings ) === 'ssp' || features.bDeferRender ) {\n\t\t\t\t_fnSortingClasses( oSettings );\n\t\t\t}\n\t\t} );\n\t\t\n\t\t\n\t\t/*\n\t\t * Table HTML init\n\t\t * Cache the header, body and footer as required, creating them if needed\n\t\t */\n\t\tvar caption = $this.children('caption');\n\t\t\n\t\tif ( oSettings.caption ) {\n\t\t\tif ( caption.length === 0 ) {\n\t\t\t\tcaption = $('<caption/>').appendTo( $this );\n\t\t\t}\n\t\t\n\t\t\tcaption.html( oSettings.caption );\n\t\t}\n\t\t\n\t\t// Store the caption side, so we can remove the element from the document\n\t\t// when creating the element\n\t\tif (caption.length) {\n\t\t\tcaption[0]._captionSide = caption.css('caption-side');\n\t\t\toSettings.captionNode = caption[0];\n\t\t}\n\t\t\n\t\tif ( thead.length === 0 ) {\n\t\t\tthead = $('<thead/>').appendTo($this);\n\t\t}\n\t\toSettings.nTHead = thead[0];\n\t\t$('tr', thead).addClass(oClasses.thead.row);\n\t\t\n\t\tvar tbody = $this.children('tbody');\n\t\tif ( tbody.length === 0 ) {\n\t\t\ttbody = $('<tbody/>').insertAfter(thead);\n\t\t}\n\t\toSettings.nTBody = tbody[0];\n\t\t\n\t\tvar tfoot = $this.children('tfoot');\n\t\tif ( tfoot.length === 0 ) {\n\t\t\t// If we are a scrolling table, and no footer has been given, then we need to create\n\t\t\t// a tfoot element for the caption element to be appended to\n\t\t\ttfoot = $('<tfoot/>').appendTo($this);\n\t\t}\n\t\toSettings.nTFoot = tfoot[0];\n\t\t$('tr', tfoot).addClass(oClasses.tfoot.row);\n\t\t\n\t\t// Copy the data index array\n\t\toSettings.aiDisplay = oSettings.aiDisplayMaster.slice();\n\t\t\n\t\t// Initialisation complete - table can be drawn\n\t\toSettings.bInitialised = true;\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\t// Get the language definitions from a file\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$.extend( true, oLanguage, json, oSettings.oInit.oLanguage );\n\t\t\n\t\t\t\t\t_fnCallbackFire( oSettings, null, 'i18n', [oSettings], true);\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\n\t\t\t\t\t_fnLog( oSettings, 0, 'i18n file loading error', 21 );\n\t\t\n\t\t\t\t\t// 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}\n\t\telse {\n\t\t\t_fnCallbackFire( oSettings, null, 'i18n', [oSettings]);\n\t\t\t_fnInitialise( oSettings );\n\t\t}\n\t} );\n\t_that = null;\n\treturn this;\n};\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 * Legacy so v1 plug-ins don't throw js errors on load\n\t */\n\tfeature: [],\n\n\t/**\n\t * Feature plug-ins.\n\t * \n\t * This is an object of callbacks which provide the features for DataTables\n\t * to be initialised via the `layout` option.\n\t */\n\tfeatures: {},\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 * 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 * Automatic column class assignment\n\t\t */\n\t\tclassName: {},\n\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\t\t/**\n\t\t * Automatic renderer assignment\n\t\t */\n\t\trender: {},\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 * 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\toStdClasses:  _ext.classes,\n\toPagination:  _ext.pager\n} );\n\n\n$.extend( DataTable.ext.classes, {\n\tcontainer: 'dt-container',\n\tempty: {\n\t\trow: 'dt-empty'\n\t},\n\tinfo: {\n\t\tcontainer: 'dt-info'\n\t},\n\tlayout: {\n\t\trow: 'dt-layout-row',\n\t\tcell: 'dt-layout-cell',\n\t\ttableRow: 'dt-layout-table',\n\t\ttableCell: '',\n\t\tstart: 'dt-layout-start',\n\t\tend: 'dt-layout-end',\n\t\tfull: 'dt-layout-full'\n\t},\n\tlength: {\n\t\tcontainer: 'dt-length',\n\t\tselect: 'dt-input'\n\t},\n\torder: {\n\t\tcanAsc: 'dt-orderable-asc',\n\t\tcanDesc: 'dt-orderable-desc',\n\t\tisAsc: 'dt-ordering-asc',\n\t\tisDesc: 'dt-ordering-desc',\n\t\tnone: 'dt-orderable-none',\n\t\tposition: 'sorting_'\n\t},\n\tprocessing: {\n\t\tcontainer: 'dt-processing'\n\t},\n\tscrolling: {\n\t\tbody: 'dt-scroll-body',\n\t\tcontainer: 'dt-scroll',\n\t\tfooter: {\n\t\t\tself: 'dt-scroll-foot',\n\t\t\tinner: 'dt-scroll-footInner'\n\t\t},\n\t\theader: {\n\t\t\tself: 'dt-scroll-head',\n\t\t\tinner: 'dt-scroll-headInner'\n\t\t}\n\t},\n\tsearch: {\n\t\tcontainer: 'dt-search',\n\t\tinput: 'dt-input'\n\t},\n\ttable: 'dataTable',\t\n\ttbody: {\n\t\tcell: '',\n\t\trow: ''\n\t},\n\tthead: {\n\t\tcell: '',\n\t\trow: ''\n\t},\n\ttfoot: {\n\t\tcell: '',\n\t\trow: ''\n\t},\n\tpaging: {\n\t\tactive: 'current',\n\t\tbutton: 'dt-paging-button',\n\t\tcontainer: 'dt-paging',\n\t\tdisabled: 'disabled',\n\t\tnav: ''\n\t}\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_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;\nvar _max_str_len = Math.pow(2, 28);\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, allowEmpty ) {\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 ( allowEmpty && _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// Is a string a number surrounded by HTML?\nvar _htmlNumeric = function ( d, decimalPoint, formatted, allowEmpty ) {\n\tif ( allowEmpty && _empty( d ) ) {\n\t\treturn true;\n\t}\n\n\t// input and select strings mean that this isn't just a number\n\tif (typeof d === 'string' && d.match(/<(input|select)/i)) {\n\t\treturn null;\n\t}\n\n\tvar html = _isHtml( d );\n\treturn ! html ?\n\t\tnull :\n\t\t_isNumber( _stripHtml( d ), decimalPoint, formatted, allowEmpty ) ?\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\tif ( a[ order[i] ] ) {\n\t\t\t\tout.push( a[ order[i] ][ prop ] );\n\t\t\t}\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// Replaceable function in api.util\nvar _stripHtml = function (input) {\n\tif (! input || typeof input !== 'string') {\n\t\treturn input;\n\t}\n\n\t// Irrelevant check to workaround CodeQL's false positive on the regex\n\tif (input.length > _max_str_len) {\n\t\tthrow new Error('Exceeded max str len');\n\t}\n\n\tvar previous;\n\n\tinput = input.replace(_re_html, ''); // Complete tags\n\n\t// Safety for incomplete script tag - use do / while to ensure that\n\t// we get all instances\n\tdo {\n\t\tprevious = input;\n\t\tinput = input.replace(/<script/i, '');\n\t} while (input !== previous);\n\n\treturn previous;\n};\n\n// Replaceable function in api.util\nvar _escapeHtml = 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// Remove diacritics from a string by decomposing it and then removing\n// non-ascii characters\nvar _normalize = function (str, both) {\n\tif (typeof str !== 'string') {\n\t\treturn str;\n\t}\n\n\t// It is faster to just run `normalize` than it is to check if\n\t// we need to with a regex!\n\tvar res = str.normalize(\"NFD\");\n\n\t// Equally, here we check if a regex is needed or not\n\treturn res.length !== str.length\n\t\t? (both === true ? str + ' ' : '' ) + res.replace(/[\\u0300-\\u036f]/g, \"\")\n\t\t: res;\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 (Array.from && Set) {\n\t\treturn Array.from(new Set(src));\n\t}\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.app/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\n// Similar to jQuery's addClass, but use classList.add\nfunction _addClass(el, name) {\n\tif (name) {\n\t\tname.split(' ').forEach(function (n) {\n\t\t\tif (n) {\n\t\t\t\t// `add` does deduplication, so no need to check `contains`\n\t\t\t\tel.classList.add(n);\n\t\t\t}\n\t\t});\n\t}\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 * Return a string with diacritic characters decomposed\n\t * @param {*} mixed Function or string to normalize\n\t * @param {*} both Return original string and the normalized string\n\t * @returns String or undefined\n\t */\n\tdiacritics: function (mixed, both) {\n\t\tvar type = typeof mixed;\n\n\t\tif (type !== 'function') {\n\t\t\treturn _normalize(mixed, both);\n\t\t}\n\t\t_normalize = mixed;\n\t},\n\n\t/**\n\t * Debounce a 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\tdebounce: function ( fn, timeout ) {\n\t\tvar timer;\n\n\t\treturn function () {\n\t\t\tvar that = this;\n\t\t\tvar args = arguments;\n\n\t\t\tclearTimeout(timer);\n\n\t\t\ttimer = setTimeout( function () {\n\t\t\t\tfn.apply(that, args);\n\t\t\t}, timeout || 250 );\n\t\t};\n\t},\n\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\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 (\n\t\t\ttypeof source === 'string' && (source.indexOf('.') !== -1 ||\n\t\t\tsource.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 (\n\t\t\ttypeof source === 'string' && (source.indexOf('.') !== -1 ||\n\t\t\tsource.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) { // 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\tstripHtml: function (mixed) {\n\t\tvar type = typeof mixed;\n\n\t\tif (type === 'function') {\n\t\t\t_stripHtml = mixed;\n\t\t\treturn;\n\t\t}\n\t\telse if (type === 'string') {\n\t\t\treturn _stripHtml(mixed);\n\t\t}\n\t\treturn mixed;\n\t},\n\n\tescapeHtml: function (mixed) {\n\t\tvar type = typeof mixed;\n\n\t\tif (type === 'function') {\n\t\t\t_escapeHtml = mixed;\n\t\t\treturn;\n\t\t}\n\t\telse if (type === 'string' || Array.isArray(mixed)) {\n\t\t\treturn _escapeHtml(mixed);\n\t\t}\n\t\treturn mixed;\n\t},\n\n\tunique: _unique\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) {\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) {\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 * 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\t// Enable search delay if server-side processing is enabled\n\tif (init.serverSide && ! init.searchDelay) {\n\t\tinit.searchDelay = 400;\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: -1 * window.pageXOffset, // 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// Get scrollbar width\n\t\tbrowser.barWidth = outer[0].offsetWidth - outer[0].clientWidth;\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\tn.remove();\n\t}\n\n\t$.extend( settings.oBrowser, DataTable.__browser );\n\tsettings.oScroll.iBarWidth = DataTable.__browser.barWidth;\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 *  @memberof DataTable#oApi\n */\nfunction _fnAddColumn( oSettings )\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\"aDataSort\": oDefaults.aDataSort ? oDefaults.aDataSort : [iCol],\n\t\t\"mData\": oDefaults.mData ? oDefaults.mData : iCol,\n\t\tidx: iCol,\n\t\tsearchFixed: {},\n\t\tcolEl: $('<col>').attr('data-dt-column', 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\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\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\t\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\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\t}\n\n\t/* Cache the data get and set functions for speed */\n\tvar mDataSrc = oCol.mData;\n\tvar mData = _fnGetObjectDataFn( mDataSrc );\n\n\t// The `render` option can be given as an array to access the helper rendering methods.\n\t// The first element is the rendering method to use, the rest are the parameters to pass\n\tif ( oCol.mRender && Array.isArray( oCol.mRender ) ) {\n\t\tvar copy = oCol.mRender.slice();\n\t\tvar name = copy.shift();\n\n\t\toCol.mRender = DataTable.render[name].apply(window, copy);\n\t}\n\n\toCol._render = 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 oCol._render && type ?\n\t\t\toCol._render( 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}\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_fnCalculateColumnWidths( settings );\n\t_fnColumnSizes( settings );\n\n\tvar scroll = settings.oScroll;\n\tif ( scroll.sY !== '' || scroll.sX !== '') {\n\t\t_fnScrollDraw( settings );\n\t}\n\n\t_fnCallbackFire( settings, null, 'column-sizing', [settings] );\n}\n\n/**\n * Apply column sizes\n *\n * @param {*} settings DataTables settings object\n */\nfunction _fnColumnSizes ( settings )\n{\n\tvar cols = settings.aoColumns;\n\n\tfor (var i=0 ; i<cols.length ; i++) {\n\t\tvar width = _fnColumnsSumWidth(settings, [i], false, false);\n\n\t\t// Need to set the min-width, otherwise the browser might try to collapse\n\t\t// it further\n\t\tcols[i].colEl\n\t\t\t.css('width', width)\n\t\t\t.css('min-width', width);\n\t}\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 = aiVis.indexOf(iMatch);\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( settings )\n{\n\tvar layout = settings.aoHeader;\n\tvar columns = settings.aoColumns;\n\tvar vis = 0;\n\n\tif ( layout.length ) {\n\t\tfor ( var i=0, ien=layout[0].length ; i<ien ; i++ ) {\n\t\t\tif ( columns[i].bVisible && $(layout[0][i].cell).css('display') !== 'none' ) {\n\t\t\t\tvis++;\n\t\t\t}\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\toSettings.aoColumns.map( 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 * Allow the result from a type detection function to be `true` while\n * translating that into a string. Old type detection functions will\n * return the type name if it passes. An obect store would be better,\n * but not backwards compatible.\n *\n * @param {*} typeDetect Object or function for type detection\n * @param {*} res Result from the type detection function\n * @returns Type name or false\n */\nfunction _typeResult (typeDetect, res) {\n\treturn res === true\n\t\t? typeDetect.name\n\t\t: res;\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, detectedType, cache;\n\n\t// If SSP then we don't have the full data set, so any type detection would be\n\t// unreliable and error prone\n\tif (_fnDataSource( settings ) === 'ssp') {\n\t\treturn;\n\t}\n\n\t// For each column, spin over the data type detection functions, seeing if one matches\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\tvar typeDetect = types[j];\n\n\t\t\t\t// There can be either one, or three type detection functions\n\t\t\t\tvar oneOf = typeDetect.oneOf;\n\t\t\t\tvar allOf = typeDetect.allOf || typeDetect;\n\t\t\t\tvar init = typeDetect.init;\n\t\t\t\tvar one = false;\n\n\t\t\t\tdetectedType = null;\n\n\t\t\t\t// Fast detect based on column assignment\n\t\t\t\tif (init) {\n\t\t\t\t\tdetectedType = _typeResult(typeDetect, init(settings, col, i));\n\n\t\t\t\t\tif (detectedType) {\n\t\t\t\t\t\tcol.sType = detectedType;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tfor ( k=0, ken=data.length ; k<ken ; k++ ) {\n\t\t\t\t\tif (! data[k]) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\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\t// Only one data point in the column needs to match this function\n\t\t\t\t\tif (oneOf && ! one) {\n\t\t\t\t\t\tone = _typeResult(typeDetect, oneOf( cache[k], settings ));\n\t\t\t\t\t}\n\n\t\t\t\t\t// All data points need to match this function\n\t\t\t\t\tdetectedType = _typeResult(typeDetect, allOf( 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-3 ) {\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 ( (oneOf && one && detectedType) || (!oneOf && 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\n\t\t// Set class names for header / footer for auto type classes\n\t\tvar autoClass = _ext.type.className[col.sType];\n\n\t\tif (autoClass) {\n\t\t\t_columnAutoClass(settings.aoHeader, i, autoClass);\n\t\t\t_columnAutoClass(settings.aoFooter, i, autoClass);\n\t\t}\n\n\t\tvar renderer = _ext.type.render[col.sType];\n\n\t\t// This can only happen once! There is no way to remove\n\t\t// a renderer. After the first time the renderer has\n\t\t// already been set so createTr will run the renderer itself.\n\t\tif (renderer && ! col._render) {\n\t\t\tcol._render = DataTable.util.get(renderer);\n\n\t\t\t_columnAutoRender(settings, i);\n\t\t}\n\t}\n}\n\n/**\n * Apply an auto detected renderer to data which doesn't yet have\n * a renderer\n */\nfunction _columnAutoRender(settings, colIdx) {\n\tvar data = settings.aoData;\n\n\tfor (var i=0 ; i<data.length ; i++) {\n\t\tif (data[i].nTr) {\n\t\t\t// We have to update the display here since there is no\n\t\t\t// invalidation check for the data\n\t\t\tvar display = _fnGetCellData( settings, i, colIdx, 'display' );\n\n\t\t\tdata[i].displayData[colIdx] = display;\n\t\t\t_fnWriteCell(data[i].anCells[colIdx], display);\n\n\t\t\t// No need to update sort / filter data since it has\n\t\t\t// been invalidated and will be re-read with the\n\t\t\t// renderer now applied\n\t\t}\n\t}\n}\n\n/**\n * Apply a class name to a column's header cells\n */\nfunction _columnAutoClass(container, colIdx, className) {\n\tcontainer.forEach(function (row) {\n\t\tif (row[colIdx] && row[colIdx].unique) {\n\t\t\t_addClass(row[colIdx].cell, className);\n\t\t}\n\t});\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 {array} headerLayout Layout for header as it was loaded\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, headerLayout, fn )\n{\n\tvar i, iLen, j, jLen, k, kLen, def;\n\tvar columns = oSettings.aoColumns;\n\n\tif ( aoCols ) {\n\t\tfor ( i=0, iLen=aoCols.length ; i<iLen ; i++ ) {\n\t\t\tif (aoCols[i] && aoCols[i].name) {\n\t\t\t\tcolumns[i].sName = aoCols[i].name;\n\t\t\t}\n\t\t}\n\t}\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\tvar target = aTargets[j];\n\n\t\t\t\tif ( typeof target === 'number' && target >= 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 <= target )\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( target, def );\n\t\t\t\t}\n\t\t\t\telse if ( typeof target === 'number' && target < 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+target, def );\n\t\t\t\t}\n\t\t\t\telse if ( typeof target === 'string' )\n\t\t\t\t{\n\t\t\t\t\tfor ( k=0, kLen=columns.length ; k<kLen ; k++ ) {\n\t\t\t\t\t\tif (target === '_all') {\n\t\t\t\t\t\t\t// Apply to all columns\n\t\t\t\t\t\t\tfn( k, def );\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse if (target.indexOf(':name') !== -1) {\n\t\t\t\t\t\t\t// Column selector\n\t\t\t\t\t\t\tif (columns[k].sName === target.replace(':name', '')) {\n\t\t\t\t\t\t\t\tfn( k, def );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse {\n\t\t\t\t\t\t\t// Cell selector\n\t\t\t\t\t\t\theaderLayout.forEach(function (row) {\n\t\t\t\t\t\t\t\tif (row[k]) {\n\t\t\t\t\t\t\t\t\tvar cell = $(row[k].cell);\n\n\t\t\t\t\t\t\t\t\t// Legacy support. Note that it means that we don't support\n\t\t\t\t\t\t\t\t\t// an element name selector only, since they are treated as\n\t\t\t\t\t\t\t\t\t// class names for 1.x compat.\n\t\t\t\t\t\t\t\t\tif (target.match(/^[a-z][\\w-]*$/i)) {\n\t\t\t\t\t\t\t\t\t\ttarget = '.' + target;\n\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\tif (cell.is( target )) {\n\t\t\t\t\t\t\t\t\t\tfn( k, def );\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Statically defined columns array\n\tif ( aoCols ) {\n\t\tfor ( i=0, iLen=aoCols.length ; i<iLen ; i++ ) {\n\t\t\tfn( i, aoCols[i] );\n\t\t}\n\t}\n}\n\n\n/**\n * Get the width for a given set of columns\n *\n * @param {*} settings DataTables settings object\n * @param {*} targets Columns - comma separated string or array of numbers\n * @param {*} original Use the original width (true) or calculated (false)\n * @param {*} incVisible Include visible columns (true) or not (false)\n * @returns Combined CSS value\n */\nfunction _fnColumnsSumWidth( settings, targets, original, incVisible ) {\n\tif ( ! Array.isArray( targets ) ) {\n\t\ttargets = _fnColumnsFromHeader( targets );\n\t}\n\n\tvar sum = 0;\n\tvar unit;\n\tvar columns = settings.aoColumns;\n\t\n\tfor ( var i=0, ien=targets.length ; i<ien ; i++ ) {\n\t\tvar column = columns[ targets[i] ];\n\t\tvar definedWidth = original ?\n\t\t\tcolumn.sWidthOrig :\n\t\t\tcolumn.sWidth;\n\n\t\tif ( ! incVisible && column.bVisible === false ) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tif ( definedWidth === null || definedWidth === undefined ) {\n\t\t\treturn null; // can't determine a defined width - browser defined\n\t\t}\n\t\telse if ( typeof definedWidth === 'number' ) {\n\t\t\tunit = 'px';\n\t\t\tsum += definedWidth;\n\t\t}\n\t\telse {\n\t\t\tvar matched = definedWidth.match(/([\\d\\.]+)([^\\d]*)/);\n\n\t\t\tif ( matched ) {\n\t\t\t\tsum += matched[1] * 1;\n\t\t\t\tunit = matched.length === 3 ?\n\t\t\t\t\tmatched[2] :\n\t\t\t\t\t'px';\n\t\t\t}\n\t\t}\n\t}\n\n\treturn sum + unit;\n}\n\nfunction _fnColumnsFromHeader( cell )\n{\n\tvar attr = $(cell).closest('[data-dt-column]').attr('data-dt-column');\n\n\tif ( ! attr ) {\n\t\treturn [];\n\t}\n\n\treturn attr.split(',').map( function (val) {\n\t\treturn val * 1;\n\t} );\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} settings dataTables settings object\n *  @param {array} data data array to be added\n *  @param {node} [tr] TR element to add to the table - optional. If not given,\n *    DataTables will create a row automatically\n *  @param {array} [tds] 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 ( settings, dataIn, tr, tds )\n{\n\t/* Create the object for storing information about this new row */\n\tvar rowIdx = settings.aoData.length;\n\tvar rowModel = $.extend( true, {}, DataTable.models.oRow, {\n\t\tsrc: tr ? 'dom' : 'data',\n\t\tidx: rowIdx\n\t} );\n\n\trowModel._aData = dataIn;\n\tsettings.aoData.push( rowModel );\n\n\tvar columns = settings.aoColumns;\n\n\tfor ( var i=0, iLen=columns.length ; i<iLen ; i++ )\n\t{\n\t\t// Invalidate the column types as the new data needs to be revalidated\n\t\tcolumns[i].sType = null;\n\t}\n\n\t/* Add to the display array */\n\tsettings.aiDisplayMaster.push( rowIdx );\n\n\tvar id = settings.rowIdFn( dataIn );\n\tif ( id !== undefined ) {\n\t\tsettings.aIds[ id ] = rowModel;\n\t}\n\n\t/* Create the DOM information, or register it if already present */\n\tif ( tr || ! settings.oFeatures.bDeferRender )\n\t{\n\t\t_fnCreateTr( settings, rowIdx, tr, tds );\n\t}\n\n\treturn rowIdx;\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 * 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 row = settings.aoData[rowIdx];\n\n\tif (! row) {\n\t\treturn undefined;\n\t}\n\n\tvar draw           = settings.iDraw;\n\tvar col            = settings.aoColumns[colIdx];\n\tvar rowData        = row._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\t// Allow for a node being returned for non-display types\n\tif (type !== 'display' && cellData && typeof cellData === 'object' && cellData.nodeName) {\n\t\tcellData = cellData.innerHTML;\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 * Write a value to a cell\n * @param {*} td Cell\n * @param {*} val Value\n */\nfunction _fnWriteCell(td, val)\n{\n\tif (val && typeof val === 'object' && val.nodeName) {\n\t\t$(td)\n\t\t\t.empty()\n\t\t\t.append(val);\n\t}\n\telse {\n\t\ttd.innerHTML = val;\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\tvar parts = str.match(/(\\\\.|[^.])+/g) || [''];\n\n\treturn parts.map( 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 * 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\n\t// Remove the cached data for the row\n\trow._aSortData = null;\n\trow._aFilterData = null;\n\trow.displayData = null;\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\t\tvar display = _fnGetRowDisplay(settings, rowIdx);\n\n\t\tif ( cells ) {\n\t\t\tif ( colIdx !== undefined ) {\n\t\t\t\t_fnWriteCell(cells[colIdx], display[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\t_fnWriteCell(cells[i], display[i]);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Column specific invalidation\n\tvar cols = settings.aoColumns;\n\tif ( colIdx !== undefined ) {\n\t\t// Type - the data might have changed\n\t\tcols[ colIdx ].sType = null;\n\n\t\t// Max length string. Its a fairly cheep recalculation, so not worth\n\t\t// something more complicated\n\t\tcols[ colIdx ].maxLenString = 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\tcols[i].maxLenString = 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, 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/**\n * Render and cache a row's display data for the columns, if required\n * @returns \n */\nfunction _fnGetRowDisplay (settings, rowIdx) {\n\tlet rowModal = settings.aoData[rowIdx];\n\tlet columns = settings.aoColumns;\n\n\tif (! rowModal.displayData) {\n\t\t// Need to render and cache\n\t\trowModal.displayData = [];\n\t\n\t\tfor ( var colIdx=0, len=columns.length ; colIdx<len ; colIdx++ ) {\n\t\t\trowModal.displayData.push(\n\t\t\t\t_fnGetCellData( settings, rowIdx, colIdx, 'display' )\n\t\t\t);\n\t\t}\n\t}\n\n\treturn rowModal.displayData;\n}\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\t\ttrClass = oSettings.oClasses.tbody.row;\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_addClass(nTr, trClass);\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 && anTds[i] ? 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\t\t\t\n\t\t\tvar display = _fnGetRowDisplay(oSettings, iRow);\n\n\t\t\t// Need to create the HTML if new, or if a rendering function is defined\n\t\t\tif (\n\t\t\t\tcreate ||\n\t\t\t\t(\n\t\t\t\t\t(oCol.mRender || oCol.mData !== i) &&\n\t\t\t\t\t(!$.isPlainObject(oCol.mData) || oCol.mData._ !== i+'.display')\n\t\t\t\t)\n\t\t\t) {\n\t\t\t\t_fnWriteCell(nTd, display[i]);\n\t\t\t}\n\n\t\t\t// column class\n\t\t\t_addClass(nTd, oCol.sClass);\n\n\t\t\t// Visibility - add or remove as required\n\t\t\tif ( oCol.bVisible && create )\n\t\t\t{\n\t\t\t\tnTr.appendChild( nTd );\n\t\t\t}\n\t\t\telse if ( ! oCol.bVisible && ! create )\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', 'row-created', [nTr, rowData, iRow, cells] );\n\t}\n\telse {\n\t\t_addClass(row.nTr, trClass);\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( settings, side )\n{\n\tvar classes = settings.oClasses;\n\tvar columns = settings.aoColumns;\n\tvar i, ien, row;\n\tvar target = side === 'header'\n\t\t? settings.nTHead\n\t\t: settings.nTFoot;\n\tvar titleProp = side === 'header' ? 'sTitle' : side;\n\n\t// Footer might be defined\n\tif (! target) {\n\t\treturn;\n\t}\n\n\t// If no cells yet and we have content for them, then create\n\tif (side === 'header' || _pluck(settings.aoColumns, titleProp).join('')) {\n\t\trow = $('tr', target);\n\n\t\t// Add a row if needed\n\t\tif (! row.length) {\n\t\t\trow = $('<tr/>').appendTo(target)\n\t\t}\n\n\t\t// Add the number of cells needed to make up to the number of columns\n\t\tif (row.length === 1) {\n\t\t\tvar cells = $('td, th', row);\n\n\t\t\tfor ( i=cells.length, ien=columns.length ; i<ien ; i++ ) {\n\t\t\t\t$('<th/>')\n\t\t\t\t\t.html( columns[i][titleProp] || '' )\n\t\t\t\t\t.appendTo( row );\n\t\t\t}\n\t\t}\n\t}\n\n\tvar detected = _fnDetectHeader( settings, target, true );\n\n\tif (side === 'header') {\n\t\tsettings.aoHeader = detected;\n\t}\n\telse {\n\t\tsettings.aoFooter = detected;\n\t}\n\n\t// ARIA role for the rows\n\t$(target).children('tr').attr('role', 'row');\n\n\t// Every cell needs to be passed through the renderer\n\t$(target).children('tr').children('th, td')\n\t\t.each( function () {\n\t\t\t_fnRenderer( settings, side )(\n\t\t\t\tsettings, $(this), classes\n\t\t\t);\n\t\t} );\n}\n\n/**\n * Build a layout structure for a header or footer\n *\n * @param {*} settings DataTables settings\n * @param {*} source Source layout array\n * @param {*} incColumns What columns should be included\n * @returns Layout array\n */\nfunction _fnHeaderLayout( settings, source, incColumns )\n{\n\tvar row, column, cell;\n\tvar local = [];\n\tvar structure = [];\n\tvar columns = settings.aoColumns;\n\tvar columnCount = columns.length;\n\tvar rowspan, colspan;\n\n\tif ( ! source ) {\n\t\treturn;\n\t}\n\n\t// Default is to work on only visible columns\n\tif ( ! incColumns ) {\n\t\tincColumns = _range(columnCount)\n\t\t\t.filter(function (idx) {\n\t\t\t\treturn columns[idx].bVisible;\n\t\t\t});\n\t}\n\n\t// Make a copy of the master layout array, but with only the columns we want\n\tfor ( row=0 ; row<source.length ; row++ ) {\n\t\t// Remove any columns we haven't selected\n\t\tlocal[row] = source[row].slice().filter(function (cell, i) {\n\t\t\treturn incColumns.includes(i);\n\t\t});\n\n\t\t// Prep the structure array - it needs an element for each row\n\t\tstructure.push( [] );\n\t}\n\n\tfor ( row=0 ; row<local.length ; row++ ) {\n\t\tfor ( column=0 ; column<local[row].length ; column++ ) {\n\t\t\trowspan = 1;\n\t\t\tcolspan = 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\tif ( structure[row][column] === undefined ) {\n\t\t\t\tcell = local[row][column].cell;\n\n\t\t\t\t// Expand for rowspan\n\t\t\t\twhile (\n\t\t\t\t\tlocal[row+rowspan] !== undefined &&\n\t\t\t\t\tlocal[row][column].cell == local[row+rowspan][column].cell\n\t\t\t\t) {\n\t\t\t\t\tstructure[row+rowspan][column] = null;\n\t\t\t\t\trowspan++;\n\t\t\t\t}\n\n\t\t\t\t// And for colspan\n\t\t\t\twhile (\n\t\t\t\t\tlocal[row][column+colspan] !== undefined &&\n\t\t\t\t\tlocal[row][column].cell == local[row][column+colspan].cell\n\t\t\t\t) {\n\t\t\t\t\t// Which also needs to go over rows\n\t\t\t\t\tfor ( var k=0 ; k<rowspan ; k++ ) {\n\t\t\t\t\t\tstructure[row+k][column+colspan] = null;\n\t\t\t\t\t}\n\n\t\t\t\t\tcolspan++;\n\t\t\t\t}\n\n\t\t\t\tvar titleSpan = $('span.dt-column-title', cell);\n\n\t\t\t\tstructure[row][column] = {\n\t\t\t\t\tcell: cell,\n\t\t\t\t\tcolspan: colspan,\n\t\t\t\t\trowspan: rowspan,\n\t\t\t\t\ttitle: titleSpan.length\n\t\t\t\t\t\t? titleSpan.html()\n\t\t\t\t\t\t: $(cell).html()\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\t}\n\n\treturn structure;\n}\n\n\n/**\n * Draw the header (or footer) element based on the column visibility states.\n *\n *  @param object oSettings dataTables settings object\n *  @param array aoSource Layout array from _fnDetectHeader\n *  @memberof DataTable#oApi\n */\nfunction _fnDrawHead( settings, source )\n{\n\tvar layout = _fnHeaderLayout(settings, source);\n\tvar tr, n;\n\n\tfor ( var row=0 ; row<source.length ; row++ ) {\n\t\ttr = source[row].row;\n\n\t\t// All cells are going to be replaced, so empty out the row\n\t\t// Can't use $().empty() as that kills event handlers\n\t\tif (tr) {\n\t\t\twhile( (n = tr.firstChild) ) {\n\t\t\t\ttr.removeChild( n );\n\t\t\t}\n\t\t}\n\n\t\tfor ( var column=0 ; column<layout[row].length ; column++ ) {\n\t\t\tvar point = layout[row][column];\n\n\t\t\tif (point) {\n\t\t\t\t$(point.cell)\n\t\t\t\t\t.appendTo(tr)\n\t\t\t\t\t.attr('rowspan', point.rowspan)\n\t\t\t\t\t.attr('colspan', point.colspan);\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 ( aPreDraw.indexOf(false) !== -1 )\n\t{\n\t\t_fnProcessingDisplay( oSettings, false );\n\t\treturn;\n\t}\n\n\tvar anRows = [];\n\tvar iRowCount = 0;\n\tvar bServerSide = _fnDataSource( oSettings ) == 'ssp';\n\tvar aiDisplay = oSettings.aiDisplay;\n\tvar iDisplayStart = oSettings._iDisplayStart;\n\tvar iDisplayEnd = oSettings.fnDisplayEnd();\n\tvar columns = oSettings.aoColumns;\n\tvar body = $(oSettings.nTBody);\n\n\toSettings.bDrawing = true;\n\n\t/* Server-side processing draw intercept */\n\tif ( oSettings.deferLoading )\n\t{\n\t\toSettings.deferLoading = 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// Show loading message for server-side processing\n\t\tif (oSettings.iDraw === 0) {\n\t\t\tbody.empty().append(_emptyRow(oSettings));\n\t\t}\n\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// Add various classes as needed\n\t\t\tfor (var i=0 ; i<columns.length ; i++) {\n\t\t\t\tvar col = columns[i];\n\t\t\t\tvar td = aoData.anCells[i];\n\n\t\t\t\t_addClass(td, _ext.type.className[col.sType]); // auto class\n\t\t\t\t_addClass(td, oSettings.oClasses.tbody.cell); // all cells\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\tanRows[ 0 ] = _emptyRow(oSettings);\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\t// replaceChildren is faster, but only became widespread in 2020,\n\t// so a fall back in jQuery is provided for older browsers.\n\tif (body[0].replaceChildren) {\n\t\tbody[0].replaceChildren.apply(body[0], anRows);\n\t}\n\telse {\n\t\tbody.children().detach();\n\t\tbody.append( $(anRows) );\n\t}\n\n\t// Empty table needs a specific class\n\t$(oSettings.nTableWrapper).toggleClass('dt-empty-footer', $('tr', oSettings.nTFoot).length === 0);\n\n\t/* Call all required callback functions for the end of a draw */\n\t_fnCallbackFire( oSettings, 'aoDrawCallback', 'draw', [oSettings], true );\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, recompute )\n{\n\tvar\n\t\tfeatures = settings.oFeatures,\n\t\tsort     = features.bSort,\n\t\tfilter   = features.bFilter;\n\n\tif (recompute === undefined || recompute === true) {\n\t\t// Resolve any column types that are unknown due to addition or invalidation\n\t\t_fnColumnTypes( settings );\n\n\t\tif ( sort ) {\n\t\t\t_fnSort( settings );\n\t\t}\n\n\t\tif ( filter ) {\n\t\t\t_fnFilterComplete( settings, settings.oPreviousSearch );\n\t\t}\n\t\telse {\n\t\t\t// No filtering, so we want to just use the display master\n\t\t\tsettings.aiDisplay = settings.aiDisplayMaster.slice();\n\t\t}\n\t}\n\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 * Table is empty - create a row with an empty message in it\n */\nfunction _emptyRow ( settings ) {\n\tvar oLang = settings.oLanguage;\n\tvar zero = oLang.sZeroRecords;\n\tvar dataSrc = _fnDataSource( settings );\n\n\tif (\n\t\t(settings.iDraw < 1 && dataSrc === 'ssp') ||\n\t\t(settings.iDraw <= 1 && dataSrc === 'ajax')\n\t) {\n\t\tzero = oLang.sLoadingRecords;\n\t}\n\telse if ( oLang.sEmptyTable && settings.fnRecordsTotal() === 0 )\n\t{\n\t\tzero = oLang.sEmptyTable;\n\t}\n\n\treturn $( '<tr/>' )\n\t\t.append( $('<td />', {\n\t\t\t'colSpan': _fnVisbleColumns( settings ),\n\t\t\t'class':   settings.oClasses.empty.row\n\t\t} ).html( zero ) )[0];\n}\n\n\n/**\n * Expand the layout items into an object for the rendering function\n */\nfunction _layoutItems (row, align, items) {\n\tif ( Array.isArray(items)) {\n\t\tfor (var i=0 ; i<items.length ; i++) {\n\t\t\t_layoutItems(row, align, items[i]);\n\t\t}\n\n\t\treturn;\n\t}\n\n\tvar rowCell = row[align];\n\n\t// If it is an object, then there can be multiple features contained in it\n\tif ( $.isPlainObject( items ) ) {\n\t\t// A feature plugin cannot be named \"features\" due to this check\n\t\tif (items.features) {\n\t\t\tif (items.rowId) {\n\t\t\t\trow.id = items.rowId;\n\t\t\t}\n\t\t\tif (items.rowClass) {\n\t\t\t\trow.className = items.rowClass;\n\t\t\t}\n\n\t\t\trowCell.id = items.id;\n\t\t\trowCell.className = items.className;\n\n\t\t\t_layoutItems(row, align, items.features);\n\t\t}\n\t\telse {\n\t\t\tObject.keys(items).map(function (key) {\n\t\t\t\trowCell.contents.push( {\n\t\t\t\t\tfeature: key,\n\t\t\t\t\topts: items[key]\n\t\t\t\t});\n\t\t\t});\n\t\t}\n\t}\n\telse {\n\t\trowCell.contents.push(items);\n\t}\n}\n\n/**\n * Find, or create a layout row\n */\nfunction _layoutGetRow(rows, rowNum, align) {\n\tvar row;\n\n\t// Find existing rows\n\tfor (var i=0; i<rows.length; i++) {\n\t\trow = rows[i];\n\n\t\tif (row.rowNum === rowNum) {\n\t\t\t// full is on its own, but start and end share a row\n\t\t\tif (\n\t\t\t\t(align === 'full' && row.full) ||\n\t\t\t\t((align === 'start' || align === 'end') && (row.start || row.end))\n\t\t\t) {\n\t\t\t\tif (! row[align]) {\n\t\t\t\t\trow[align] = {\n\t\t\t\t\t\tcontents: []\n\t\t\t\t\t};\n\t\t\t\t}\n\n\t\t\t\treturn row;\n\t\t\t}\n\t\t}\n\t}\n\n\t// If we get this far, then there was no match, create a new row\n\trow = {\n\t\trowNum: rowNum\t\n\t};\n\n\trow[align] = {\n\t\tcontents: []\n\t};\n\n\trows.push(row);\n\n\treturn row;\n}\n\n/**\n * Convert a `layout` object given by a user to the object structure needed\n * for the renderer. This is done twice, once for above and once for below\n * the table. Ordering must also be considered.\n *\n * @param {*} settings DataTables settings object\n * @param {*} layout Layout object to convert\n * @param {string} side `top` or `bottom`\n * @returns Converted array structure - one item for each row.\n */\nfunction _layoutArray ( settings, layout, side ) {\n\tvar rows = [];\n\t\n\t// Split out into an array\n\t$.each( layout, function ( pos, items ) {\n\t\tif (items === null) {\n\t\t\treturn;\n\t\t}\n\n\t\tvar parts = pos.match(/^([a-z]+)([0-9]*)([A-Za-z]*)$/);\n\t\tvar rowNum = parts[2]\n\t\t\t? parts[2] * 1\n\t\t\t: 0;\n\t\tvar align = parts[3]\n\t\t\t? parts[3].toLowerCase()\n\t\t\t: 'full';\n\n\t\t// Filter out the side we aren't interested in\n\t\tif (parts[1] !== side) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Get or create the row we should attach to\n\t\tvar row = _layoutGetRow(rows, rowNum, align);\n\n\t\t_layoutItems(row, align, items);\n\t});\n\n\t// Order by item identifier\n\trows.sort( function ( a, b ) {\n\t\tvar order1 = a.rowNum;\n\t\tvar order2 = b.rowNum;\n\n\t\t// If both in the same row, then the row with `full` comes first\n\t\tif (order1 === order2) {\n\t\t\tvar ret = a.full && ! b.full ? -1 : 1;\n\n\t\t\treturn side === 'bottom'\n\t\t\t\t? ret * -1\n\t\t\t\t: ret;\n\t\t}\n\n\t\treturn order2 - order1;\n\t} );\n\n\t// Invert for below the table\n\tif ( side === 'bottom' ) {\n\t\trows.reverse();\n\t}\n\n\tfor (var row = 0; row<rows.length; row++) {\n\t\tdelete rows[row].rowNum;\n\n\t\t_layoutResolve(settings, rows[row]);\n\t}\n\n\treturn rows;\n}\n\n\n/**\n * Convert the contents of a row's layout object to nodes that can be inserted\n * into the document by a renderer. Execute functions, look up plug-ins, etc.\n *\n * @param {*} settings DataTables settings object\n * @param {*} row Layout object for this row\n */\nfunction _layoutResolve( settings, row ) {\n\tvar getFeature = function (feature, opts) {\n\t\tif ( ! _ext.features[ feature ] ) {\n\t\t\t_fnLog( settings, 0, 'Unknown feature: '+ feature );\n\t\t}\n\n\t\treturn _ext.features[ feature ].apply( this, [settings, opts] );\n\t};\n\n\tvar resolve = function ( item ) {\n\t\tif (! row[ item ]) {\n\t\t\treturn;\n\t\t}\n\n\t\tvar line = row[ item ].contents;\n\n\t\tfor ( var i=0, ien=line.length ; i<ien ; i++ ) {\n\t\t\tif ( ! line[i] ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\telse if ( typeof line[i] === 'string' ) {\n\t\t\t\tline[i] = getFeature( line[i], null );\n\t\t\t}\n\t\t\telse if ( $.isPlainObject(line[i]) ) {\n\t\t\t\t// If it's an object, it just has feature and opts properties from\n\t\t\t\t// the transform in _layoutArray\n\t\t\t\tline[i] = getFeature(line[i].feature, line[i].opts);\n\t\t\t}\n\t\t\telse if ( typeof line[i].node === 'function' ) {\n\t\t\t\tline[i] = line[i].node( settings );\n\t\t\t}\n\t\t\telse if ( typeof line[i] === 'function' ) {\n\t\t\t\tvar inst = line[i]( settings );\n\n\t\t\t\tline[i] = typeof inst.node === 'function' ?\n\t\t\t\t\tinst.node() :\n\t\t\t\t\tinst;\n\t\t\t}\n\t\t}\n\t};\n\n\tresolve('start');\n\tresolve('end');\n\tresolve('full');\n}\n\n\n/**\n * Add the options to the page HTML for the table\n *  @param {object} settings DataTables settings object\n *  @memberof DataTable#oApi\n */\nfunction _fnAddOptionsHtml ( settings )\n{\n\tvar classes = settings.oClasses;\n\tvar table = $(settings.nTable);\n\n\t// Wrapper div around everything DataTables controls\n\tvar insert = $('<div/>')\n\t\t.attr({\n\t\t\tid:      settings.sTableId+'_wrapper',\n\t\t\t'class': classes.container\n\t\t})\n\t\t.insertBefore(table);\n\n\tsettings.nTableWrapper = insert[0];\n\n\tif (settings.sDom) {\n\t\t// Legacy\n\t\t_fnLayoutDom(settings, settings.sDom, insert);\n\t}\n\telse {\n\t\tvar top = _layoutArray( settings, settings.layout, 'top' );\n\t\tvar bottom = _layoutArray( settings, settings.layout, 'bottom' );\n\t\tvar renderer = _fnRenderer( settings, 'layout' );\n\t\n\t\t// Everything above - the renderer will actually insert the contents into the document\n\t\ttop.forEach(function (item) {\n\t\t\trenderer( settings, insert, item );\n\t\t});\n\n\t\t// The table - always the center of attention\n\t\trenderer( settings, insert, {\n\t\t\tfull: {\n\t\t\t\ttable: true,\n\t\t\t\tcontents: [ _fnFeatureHtmlTable(settings) ]\n\t\t\t}\n\t\t} );\n\n\t\t// Everything below\n\t\tbottom.forEach(function (item) {\n\t\t\trenderer( settings, insert, item );\n\t\t});\n\t}\n\n\t// Processing floats on top, so it isn't an inserted feature\n\t_processingHtml( settings );\n}\n\n/**\n * Draw the table with the legacy DOM property\n * @param {*} settings DT settings object\n * @param {*} dom DOM string\n * @param {*} insert Insert point\n */\nfunction _fnLayoutDom( settings, dom, insert )\n{\n\tvar parts = dom.match(/(\".*?\")|('.*?')|./g);\n\tvar featureNode, option, newNode, next, attr;\n\n\tfor ( var i=0 ; i<parts.length ; i++ ) {\n\t\tfeatureNode = null;\n\t\toption = parts[i];\n\n\t\tif ( option == '<' ) {\n\t\t\t// New container div\n\t\t\tnewNode = $('<div/>');\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\tnext = parts[i+1];\n\n\t\t\tif ( next[0] == \"'\" || next[0] == '\"' ) {\n\t\t\t\tattr = next.replace(/['\"]/g, '');\n\n\t\t\t\tvar id = '', className;\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 ( attr.indexOf('.') != -1 ) {\n\t\t\t\t\tvar split = attr.split('.');\n\n\t\t\t\t\tid = split[0];\n\t\t\t\t\tclassName = split[1];\n\t\t\t\t}\n\t\t\t\telse if ( attr[0] == \"#\" ) {\n\t\t\t\t\tid = attr;\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tclassName = attr;\n\t\t\t\t}\n\n\t\t\t\tnewNode\n\t\t\t\t\t.attr('id', id.substring(1))\n\t\t\t\t\t.addClass(className);\n\n\t\t\t\ti++; // Move along the position array\n\t\t\t}\n\n\t\t\tinsert.append( newNode );\n\t\t\tinsert = newNode;\n\t\t}\n\t\telse if ( option == '>' ) {\n\t\t\t// End container div\n\t\t\tinsert = insert.parent();\n\t\t}\n\t\telse if ( option == 't' ) {\n\t\t\t// Table\n\t\t\tfeatureNode = _fnFeatureHtmlTable( settings );\n\t\t}\n\t\telse\n\t\t{\n\t\t\tDataTable.ext.feature.forEach(function(feature) {\n\t\t\t\tif ( option == feature.cFeature ) {\n\t\t\t\t\tfeatureNode = feature.fnInit( settings );\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\n\t\t// Add to the display\n\t\tif ( featureNode ) {\n\t\t\tinsert.append( featureNode );\n\t\t}\n\t}\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 {node} thead The header/footer element for the table\n *  @returns {array} Calculated layout array\n *  @memberof DataTable#oApi\n */\nfunction _fnDetectHeader ( settings, thead, write )\n{\n\tvar columns = settings.aoColumns;\n\tvar rows = $(thead).children('tr');\n\tvar row, cell;\n\tvar i, k, l, iLen, shifted, column, colspan, rowspan;\n\tvar isHeader = thead && thead.nodeName.toLowerCase() === 'thead';\n\tvar layout = [];\n\tvar unique;\n\tvar shift = function ( a, i, j ) {\n\t\tvar k = a[i];\n\t\twhile ( k[j] ) {\n\t\t\tj++;\n\t\t}\n\t\treturn j;\n\t};\n\n\t// We know how many rows there are in the layout - so prep it\n\tfor ( i=0, iLen=rows.length ; i<iLen ; i++ ) {\n\t\tlayout.push( [] );\n\t}\n\n\tfor ( i=0, iLen=rows.length ; i<iLen ; i++ ) {\n\t\trow = rows[i];\n\t\tcolumn = 0;\n\n\t\t// For every cell in the row..\n\t\tcell = row.firstChild;\n\t\twhile ( cell ) {\n\t\t\tif (\n\t\t\t\tcell.nodeName.toUpperCase() == 'TD' ||\n\t\t\t\tcell.nodeName.toUpperCase() == 'TH'\n\t\t\t) {\n\t\t\t\tvar cols = [];\n\n\t\t\t\t// Get the col and rowspan attributes from the DOM and sanitise them\n\t\t\t\tcolspan = cell.getAttribute('colspan') * 1;\n\t\t\t\trowspan = cell.getAttribute('rowspan') * 1;\n\t\t\t\tcolspan = (!colspan || colspan===0 || colspan===1) ? 1 : colspan;\n\t\t\t\trowspan = (!rowspan || rowspan===0 || rowspan===1) ? 1 : rowspan;\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\tshifted = shift( layout, i, column );\n\n\t\t\t\t// Cache calculation for unique columns\n\t\t\t\tunique = colspan === 1 ?\n\t\t\t\t\ttrue :\n\t\t\t\t\tfalse;\n\t\t\t\t\n\t\t\t\t// Perform header setup\n\t\t\t\tif ( write ) {\n\t\t\t\t\tif (unique) {\n\t\t\t\t\t\t// Allow column options to be set from HTML attributes\n\t\t\t\t\t\t_fnColumnOptions( settings, shifted, $(cell).data() );\n\t\t\t\t\t\t\n\t\t\t\t\t\t// Get the width for the column. This can be defined from the\n\t\t\t\t\t\t// width attribute, style attribute or `columns.width` option\n\t\t\t\t\t\tvar columnDef = columns[shifted];\n\t\t\t\t\t\tvar width = cell.getAttribute('width') || null;\n\t\t\t\t\t\tvar t = cell.style.width.match(/width:\\s*(\\d+[pxem%]+)/);\n\t\t\t\t\t\tif ( t ) {\n\t\t\t\t\t\t\twidth = t[1];\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tcolumnDef.sWidthOrig = columnDef.sWidth || width;\n\n\t\t\t\t\t\tif (isHeader) {\n\t\t\t\t\t\t\t// Column title handling - can be user set, or read from the DOM\n\t\t\t\t\t\t\t// This happens before the render, so the original is still in place\n\t\t\t\t\t\t\tif ( columnDef.sTitle !== null && ! columnDef.autoTitle ) {\n\t\t\t\t\t\t\t\tcell.innerHTML = columnDef.sTitle;\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\tif (! columnDef.sTitle && unique) {\n\t\t\t\t\t\t\t\tcolumnDef.sTitle = _stripHtml(cell.innerHTML);\n\t\t\t\t\t\t\t\tcolumnDef.autoTitle = true;\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// Footer specific operations\n\t\t\t\t\t\t\tif (columnDef.footer) {\n\t\t\t\t\t\t\t\tcell.innerHTML = columnDef.footer;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Fall back to the aria-label attribute on the table header if no ariaTitle is\n\t\t\t\t\t\t// provided.\n\t\t\t\t\t\tif (! columnDef.ariaTitle) {\n\t\t\t\t\t\t\tcolumnDef.ariaTitle = $(cell).attr(\"aria-label\") || columnDef.sTitle;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Column specific class names\n\t\t\t\t\t\tif ( columnDef.className ) {\n\t\t\t\t\t\t\t$(cell).addClass( columnDef.className );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Wrap the column title so we can write to it in future\n\t\t\t\t\tif ( $('span.dt-column-title', cell).length === 0) {\n\t\t\t\t\t\t$('<span>')\n\t\t\t\t\t\t\t.addClass('dt-column-title')\n\t\t\t\t\t\t\t.append(cell.childNodes)\n\t\t\t\t\t\t\t.appendTo(cell);\n\t\t\t\t\t}\n\n\t\t\t\t\tif ( isHeader && $('span.dt-column-order', cell).length === 0) {\n\t\t\t\t\t\t$('<span>')\n\t\t\t\t\t\t\t.addClass('dt-column-order')\n\t\t\t\t\t\t\t.appendTo(cell);\n\t\t\t\t\t}\n\t\t\t\t}\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<colspan ; l++ ) {\n\t\t\t\t\tfor ( k=0 ; k<rowspan ; k++ ) {\n\t\t\t\t\t\tlayout[i+k][shifted+l] = {\n\t\t\t\t\t\t\tcell: cell,\n\t\t\t\t\t\t\tunique: unique\n\t\t\t\t\t\t};\n\n\t\t\t\t\t\tlayout[i+k].row = row;\n\t\t\t\t\t}\n\n\t\t\t\t\tcols.push( shifted+l );\n\t\t\t\t}\n\n\t\t\t\t// Assign an attribute so spanning cells can still be identified\n\t\t\t\t// as belonging to a column\n\t\t\t\tcell.setAttribute('data-dt-column', _unique(cols).join(','));\n\t\t\t}\n\n\t\t\tcell = cell.nextSibling;\n\t\t}\n\t}\n\n\treturn layout;\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\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\t// Microsoft often wrap JSON as a string in another JSON object\n\t\t// Let's handle that automatically\n\t\tif (json.d && typeof json.d === 'string') {\n\t\t\ttry {\n\t\t\t\tjson = JSON.parse(json.d);\n\t\t\t}\n\t\t\tcatch (e) {\n\t\t\t\t// noop\n\t\t\t}\n\t\t}\n\n\t\toSettings.json = json;\n\n\t\t_fnCallbackFire( oSettings, null, 'xhr', [oSettings, json, oSettings.jqXHR], true );\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\"url\": typeof ajax === 'string' ?\n\t\t\tajax :\n\t\t\t'',\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) {\n\t\t\tvar ret = _fnCallbackFire( oSettings, null, 'xhr', [oSettings, null, oSettings.jqXHR], true );\n\n\t\t\tif ( ret.indexOf(true) === -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// If `ajax` option is an object, extend and override our default base\n\tif ( $.isPlainObject( ajax ) ) {\n\t\t$.extend( baseAjax, ajax )\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, baseAjax], true );\n\n\tif ( 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 if (ajax.url === '') {\n\t\t// No url, so don't load any data. Just apply an empty data array\n\t\t// to the object for the callback.\n\t\tvar empty = {};\n\n\t\tDataTable.util.set(ajax.dataSrc)(empty, []);\n\t\tcallback(empty);\n\t}\n\telse {\n\t\t// Object to extend the base settings\n\t\toSettings.jqXHR = $.ajax( baseAjax );\n\t}\n\n\t// Restore for next time around\n\tif ( ajaxData ) {\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_fnBuildAjax(\n\t\tsettings,\n\t\t_fnAjaxParameters( settings ),\n\t\tfunction(json) {\n\t\t\t_fnAjaxUpdateDraw( settings, json );\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.\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\tfeatures = settings.oFeatures,\n\t\tpreSearch = settings.oPreviousSearch,\n\t\tpreColSearch = settings.aoPreSearchCols,\n\t\tcolData = function ( idx, prop ) {\n\t\t\treturn typeof columns[idx][prop] === 'function' ?\n\t\t\t\t'function' :\n\t\t\t\tcolumns[idx][prop];\n\t\t};\n\n\treturn {\n\t\tdraw: settings.iDraw,\n\t\tcolumns: columns.map( function ( column, i ) {\n\t\t\treturn {\n\t\t\t\tdata: colData(i, 'mData'),\n\t\t\t\tname: column.sName,\n\t\t\t\tsearchable: column.bSearchable,\n\t\t\t\torderable: column.bSortable,\n\t\t\t\tsearch: {\n\t\t\t\t\tvalue: preColSearch[i].search,\n\t\t\t\t\tregex: preColSearch[i].regex,\n\t\t\t\t\tfixed: Object.keys(column.searchFixed).map( function(name) {\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\tname: name,\n\t\t\t\t\t\t\tterm: column.searchFixed[name].toString()\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\torder: _fnSortFlatten( settings ).map( function ( val ) {\n\t\t\treturn {\n\t\t\t\tcolumn: val.col,\n\t\t\t\tdir: val.dir,\n\t\t\t\tname: colData(val.col, 'sName')\n\t\t\t};\n\t\t} ),\n\t\tstart: settings._iDisplayStart,\n\t\tlength: features.bPaginate ?\n\t\t\tsettings._iDisplayLength :\n\t\t\t-1,\n\t\tsearch: {\n\t\t\tvalue: preSearch.search,\n\t\t\tregex: preSearch.regex,\n\t\t\tfixed: Object.keys(settings.searchFixed).map( function(name) {\n\t\t\t\treturn {\n\t\t\t\t\tname: name,\n\t\t\t\t\tterm: settings.searchFixed[name].toString()\n\t\t\t\t}\n\t\t\t})\n\t\t}\n\t};\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\tvar data = _fnAjaxDataSrc(settings, json);\n\tvar draw = _fnAjaxDataSrcParam(settings, 'draw', json);\n\tvar recordsTotal = _fnAjaxDataSrcParam(settings, 'recordsTotal', json);\n\tvar recordsFiltered = _fnAjaxDataSrcParam(settings, 'recordsFiltered', json);\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\t_fnInitComplete( settings );\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} settings dataTables settings object\n *  @param  {object} json Data source object / array from the server\n *  @return {array} Array of data to use\n */\nfunction _fnAjaxDataSrc ( settings, json, write )\n{\n\tvar dataProp = 'data';\n\n\tif ($.isPlainObject( settings.ajax ) && settings.ajax.dataSrc !== undefined) {\n\t\t// Could in inside a `dataSrc` object, or not!\n\t\tvar dataSrc = settings.ajax.dataSrc;\n\n\t\t// string, function and object are valid types\n\t\tif (typeof dataSrc === 'string' || typeof dataSrc === 'function') {\n\t\t\tdataProp = dataSrc;\n\t\t}\n\t\telse if (dataSrc.data !== undefined) {\n\t\t\tdataProp = dataSrc.data;\n\t\t}\n\t}\n\n\tif ( ! write ) {\n\t\tif ( dataProp === '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[dataProp];\n\t\t}\n\n\t\treturn dataProp !== \"\" ?\n\t\t\t_fnGetObjectDataFn( dataProp )( json ) :\n\t\t\tjson;\n\t}\n\t\n\t// set\n\t_fnSetObjectDataFn( dataProp )( json, write );\n}\n\n/**\n * Very similar to _fnAjaxDataSrc, but for the other SSP properties\n * @param {*} settings DataTables settings object\n * @param {*} param Target parameter\n * @param {*} json JSON data\n * @returns Resolved value\n */\nfunction _fnAjaxDataSrcParam (settings, param, json) {\n\tvar dataSrc = $.isPlainObject( settings.ajax )\n\t\t? settings.ajax.dataSrc\n\t\t: null;\n\n\tif (dataSrc && dataSrc[param]) {\n\t\t// Get from custom location\n\t\treturn _fnGetObjectDataFn( dataSrc[param] )( json );\n\t}\n\n\t// else - Default behaviour\n\tvar old = '';\n\n\t// Legacy support\n\tif (param === 'draw') {\n\t\told = 'sEcho';\n\t}\n\telse if (param === 'recordsTotal') {\n\t\told = 'iTotalRecords';\n\t}\n\telse if (param === 'recordsFiltered') {\n\t\told = 'iTotalDisplayRecords';\n\t}\n\n\treturn json[old] !== undefined\n\t\t? json[old]\n\t\t: json[param];\n}\n\n\n/**\n * Filter the table using both the global filter and column based filtering\n *  @param {object} settings dataTables settings object\n *  @param {object} input search information\n *  @memberof DataTable#oApi\n */\nfunction _fnFilterComplete ( settings, input )\n{\n\tvar columnsSearch = settings.aoPreSearchCols;\n\n\t// In server-side processing all filtering is done by the server, so no point hanging around here\n\tif ( _fnDataSource( settings ) != 'ssp' )\n\t{\n\t\t// Check if any of the rows were invalidated\n\t\t_fnFilterData( settings );\n\n\t\t// Start from the full data set\n\t\tsettings.aiDisplay = settings.aiDisplayMaster.slice();\n\n\t\t// Global filter first\n\t\t_fnFilter( settings.aiDisplay, settings, input.search, input );\n\n\t\t$.each(settings.searchFixed, function (name, term) {\n\t\t\t_fnFilter(settings.aiDisplay, settings, term, {});\n\t\t});\n\n\t\t// Then individual column filters\n\t\tfor ( var i=0 ; i<columnsSearch.length ; i++ )\n\t\t{\n\t\t\tvar col = columnsSearch[i];\n\n\t\t\t_fnFilter(\n\t\t\t\tsettings.aiDisplay,\n\t\t\t\tsettings,\n\t\t\t\tcol.search,\n\t\t\t\tcol,\n\t\t\t\ti\n\t\t\t);\n\n\t\t\t$.each(settings.aoColumns[i].searchFixed, function (name, term) {\n\t\t\t\t_fnFilter(settings.aiDisplay, settings, term, {}, i);\n\t\t\t});\n\t\t}\n\n\t\t// And finally global filtering\n\t\t_fnFilterCustom( settings );\n\t}\n\n\t// Tell the draw function we have been filtering\n\tsettings.bFiltered = true;\n\n\t_fnCallbackFire( settings, null, 'search', [settings] );\n}\n\n\n/**\n * Apply custom filtering functions\n * \n * This is legacy now that we have named functions, but it is widely used\n * from 1.x, so it is not yet deprecated.\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\tdisplayRows.push.apply(displayRows, rows);\n\t}\n}\n\n\n/**\n * Filter the data table based on user input and draw the table\n */\nfunction _fnFilter( searchRows, settings, input, options, column )\n{\n\tif ( input === '' ) {\n\t\treturn;\n\t}\n\n\tvar i = 0;\n\tvar matched = [];\n\n\t// Search term can be a function, regex or string - if a string we apply our\n\t// smart filtering regex (assuming the options require that)\n\tvar searchFunc = typeof input === 'function' ? input : null;\n\tvar rpSearch = input instanceof RegExp\n\t\t? input\n\t\t: searchFunc\n\t\t\t? null\n\t\t\t: _fnFilterCreateSearch( input, options );\n\n\t// Then for each row, does the test pass. If not, lop the row from the array\n\tfor (i=0 ; i<searchRows.length ; i++) {\n\t\tvar row = settings.aoData[ searchRows[i] ];\n\t\tvar data = column === undefined\n\t\t\t? row._sFilterRow\n\t\t\t: row._aFilterData[ column ];\n\n\t\tif ( (searchFunc && searchFunc(data, row._aData, searchRows[i], column)) || (rpSearch && rpSearch.test(data)) ) {\n\t\t\tmatched.push(searchRows[i]);\n\t\t}\n\t}\n\n\t// Mutate the searchRows array\n\tsearchRows.length = matched.length;\n\n\tfor (i=0 ; i<matched.length ; i++) {\n\t\tsearchRows[i] = matched[i];\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, inOpts )\n{\n\tvar not = [];\n\tvar options = $.extend({}, {\n\t\tboundary: false,\n\t\tcaseInsensitive: true,\n\t\texact: false,\n\t\tregex: false,\n\t\tsmart: true\n\t}, inOpts);\n\n\tif (typeof search !== 'string') {\n\t\tsearch = search.toString();\n\t}\n\n\t// Remove diacritics if normalize is set up to do so\n\tsearch = _normalize(search);\n\n\tif (options.exact) {\n\t\treturn new RegExp(\n\t\t\t'^'+_fnEscapeRegex(search)+'$',\n\t\t\toptions.caseInsensitive ? 'i' : ''\n\t\t);\n\t}\n\n\tsearch = options.regex ?\n\t\tsearch :\n\t\t_fnEscapeRegex( search );\n\t\n\tif ( options.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. And a negative look around for\n\t\t * finding rows which don't contain a given string.\n\t\t * \n\t\t * So this is the sort of thing we want to generate:\n\t\t * \n\t\t * ^(?=.*?\\bone\\b)(?=.*?\\btwo three\\b)(?=.*?\\bfour\\b).*$\n\t\t */\n\t\tvar parts = search.match( /!?[\"\\u201C][^\"\\u201D]+[\"\\u201D]|[^ ]+/g ) || [''];\n\t\tvar a = parts.map( function ( word ) {\n\t\t\tvar negative = false;\n\t\t\tvar m;\n\n\t\t\t// Determine if it is a \"does not include\"\n\t\t\tif ( word.charAt(0) === '!' ) {\n\t\t\t\tnegative = true;\n\t\t\t\tword = word.substring(1);\n\t\t\t}\n\n\t\t\t// Strip the quotes from around matched phrases\n\t\t\tif ( word.charAt(0) === '\"' ) {\n\t\t\t\tm = 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\t// Smart quote match (iPhone users)\n\t\t\t\tm = word.match( /^\\u201C(.*)\\u201D$/ );\n\t\t\t\tword = m ? m[1] : word;\n\t\t\t}\n\n\t\t\t// For our \"not\" case, we need to modify the string that is\n\t\t\t// allowed to match at the end of the expression.\n\t\t\tif (negative) {\n\t\t\t\tif (word.length > 1) {\n\t\t\t\t\tnot.push('(?!'+word+')');\n\t\t\t\t}\n\n\t\t\t\tword = '';\n\t\t\t}\n\n\t\t\treturn word.replace(/\"/g, '');\n\t\t} );\n\n\t\tvar match = not.length\n\t\t\t? not.join('')\n\t\t\t: '';\n\n\t\tvar boundary = options.boundary\n\t\t\t? '\\\\b'\n\t\t\t: '';\n\n\t\tsearch = '^(?=.*?'+boundary+a.join( ')(?=.*?'+boundary )+')('+match+'.)*$';\n\t}\n\n\treturn new RegExp( search, options.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 data = settings.aoData;\n\tvar column;\n\tvar j, jen, filterData, cellData, row;\n\tvar wasInvalidated = false;\n\n\tfor ( var rowIdx=0 ; rowIdx<data.length ; rowIdx++ ) {\n\t\tif (! data[rowIdx]) {\n\t\t\tcontinue;\n\t\t}\n\n\t\trow = data[rowIdx];\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, rowIdx, j, 'filter' );\n\n\t\t\t\t\t// Search in DataTables is string based\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 * 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;\n\tvar init = settings.oInit;\n\tvar deferLoading = settings.deferLoading;\n\tvar dataSrc = _fnDataSource( settings );\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// Build the header / footer for the table\n\t_fnBuildHead( settings, 'header' );\n\t_fnBuildHead( settings, 'footer' );\n\n\t// Load the table's state (if needed) and then render around it and draw\n\t_fnLoadState( settings, init, function () {\n\t\t// Then draw the header / footer\n\t\t_fnDrawHead( settings, settings.aoHeader );\n\t\t_fnDrawHead( settings, settings.aoFooter );\n\n\t\t// Cache the paging start point, as the first redraw will reset it\n\t\tvar iAjaxStart = settings.iInitDisplayStart\n\n\t\t// Local data load\n\t\t// Check if there is data passing into the constructor\n\t\tif ( init.aaData ) {\n\t\t\tfor ( i=0 ; i<init.aaData.length ; i++ ) {\n\t\t\t\t_fnAddData( settings, init.aaData[ i ] );\n\t\t\t}\n\t\t}\n\t\telse if ( deferLoading || dataSrc == 'dom' ) {\n\t\t\t// Grab the data from the page\n\t\t\t_fnAddTr( settings, $(settings.nTBody).children('tr') );\n\t\t}\n\n\t\t// Filter not yet applied - copy the display master\n\t\tsettings.aiDisplay = settings.aiDisplayMaster.slice();\n\n\t\t// Enable features\n\t\t_fnAddOptionsHtml( settings );\n\t\t_fnSortInit( settings );\n\n\t\t_colGroup( settings );\n\n\t\t/* Okay to show that something is going on now */\n\t\t_fnProcessingDisplay( settings, true );\n\n\t\t_fnCallbackFire( settings, null, 'preInit', [settings], true );\n\n\t\t// If there is default sorting required - let's do it. The sort function\n\t\t// will do the drawing for us. Otherwise we draw the table regardless of the\n\t\t// Ajax source - this allows the table to look initialised for Ajax sourcing\n\t\t// data (show 'loading' message possibly)\n\t\t_fnReDraw( settings );\n\n\t\t// Server-side processing init complete is done by _fnAjaxUpdateDraw\n\t\tif ( dataSrc != 'ssp' || deferLoading ) {\n\t\t\t// if there is an ajax source load the data\n\t\t\tif ( dataSrc == 'ajax' ) {\n\t\t\t\t_fnBuildAjax( settings, {}, function(json) {\n\t\t\t\t\tvar aData = _fnAjaxDataSrc( settings, json );\n\n\t\t\t\t\t// Got the data - add it to the table\n\t\t\t\t\tfor ( i=0 ; i<aData.length ; i++ ) {\n\t\t\t\t\t\t_fnAddData( settings, aData[i] );\n\t\t\t\t\t}\n\n\t\t\t\t\t// Reset the init display for cookie saving. We've already done\n\t\t\t\t\t// a filter, and therefore cleared it before. So we need to make\n\t\t\t\t\t// it appear 'fresh'\n\t\t\t\t\tsettings.iInitDisplayStart = iAjaxStart;\n\n\t\t\t\t\t_fnReDraw( settings );\n\t\t\t\t\t_fnProcessingDisplay( settings, false );\n\t\t\t\t\t_fnInitComplete( settings );\n\t\t\t\t}, settings );\n\t\t\t}\n\t\t\telse {\n\t\t\t\t_fnInitComplete( settings );\n\t\t\t\t_fnProcessingDisplay( settings, false );\n\t\t\t}\n\t\t}\n\t} );\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 _fnInitComplete ( settings )\n{\n\tif (settings._bInitComplete) {\n\t\treturn;\n\t}\n\n\tvar args = [settings, settings.json];\n\n\tsettings._bInitComplete = true;\n\n\t// Table is fully set up and we have data, so calculate the\n\t// column widths\n\t_fnAdjustColumnSizing( settings );\n\n\t_fnCallbackFire( settings, null, 'plugin-init', args, true );\n\t_fnCallbackFire( settings, 'aoInitComplete', 'init', args, true );\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 * 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\tstart = 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 if ( action === 'ellipsis' )\n\t{\n\t\treturn;\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\t_fnCallbackFire( settings, null, changed ? 'page' : 'page-nc', [settings] );\n\n\tif ( changed && redraw ) {\n\t\t_fnDraw( settings );\n\t}\n\n\treturn changed;\n}\n\n\n/**\n * Generate the node required for the processing node\n *  @param {object} settings DataTables settings object\n */\nfunction _processingHtml ( settings )\n{\n\tvar table = settings.nTable;\n\tvar scrolling = settings.oScroll.sX !== '' || settings.oScroll.sY !== '';\n\n\tif ( settings.oFeatures.bProcessing ) {\n\t\tvar n = $('<div/>', {\n\t\t\t\t'id': settings.sTableId + '_processing',\n\t\t\t\t'class': settings.oClasses.processing.container,\n\t\t\t\t'role': 'status'\n\t\t\t} )\n\t\t\t.html( settings.oLanguage.sProcessing )\n\t\t\t.append('<div><div></div><div></div><div></div><div></div></div>');\n\n\t\t// Different positioning depending on if scrolling is enabled or not\n\t\tif (scrolling) {\n\t\t\tn.prependTo( $('div.dt-scroll', settings.nTableWrapper) );\n\t\t}\n\t\telse {\n\t\t\tn.insertBefore( table );\n\t\t}\n\n\t\t$(table).on( 'processing.dt.DT', function (e, s, show) {\n\t\t\tn.css( 'display', show ? 'block' : 'none' );\n\t\t} );\n\t}\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 */\nfunction _fnProcessingDisplay ( settings, show )\n{\n\t// Ignore cases when we are still redrawing\n\tif (settings.bDrawing && show === false) {\n\t\treturn;\n\t}\n\n\t_fnCallbackFire( settings, null, 'processing', [settings, show] );\n}\n\n/**\n * Show the processing element if an action takes longer than a given time\n *\n * @param {*} settings DataTables settings object\n * @param {*} enable Do (true) or not (false) async processing (local feature enablement)\n * @param {*} run Function to run\n */\nfunction _fnProcessingRun( settings, enable, run ) {\n\tif (! enable) {\n\t\t// Immediate execution, synchronous\n\t\trun();\n\t}\n\telse {\n\t\t_fnProcessingDisplay(settings, true);\n\t\t\n\t\t// Allow the processing display to show if needed\n\t\tsetTimeout(function () {\n\t\t\trun();\n\n\t\t\t_fnProcessingDisplay(settings, false);\n\t\t}, 0);\n\t}\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.scrolling;\n\tvar caption = settings.captionNode;\n\tvar captionSide = caption ? caption._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.container } )\n\t\t.append(\n\t\t\t$(_div, { 'class': classes.header.self } )\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.header.inner } )\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.body } )\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.footer.self } )\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.footer.inner } )\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\t$(scrollBody).on( 'scroll.DT', function () {\n\t\tvar scrollLeft = this.scrollLeft;\n\n\t\tscrollHead.scrollLeft = scrollLeft;\n\n\t\tif ( footer ) {\n\t\t\tscrollFoot.scrollLeft = scrollLeft;\n\t\t}\n\t} );\n\n\t// When focus is put on the header cells, we might need to scroll the body\n\t$('th, td', scrollHead).on('focus', function () {\n\t\tvar scrollLeft = scrollHead.scrollLeft;\n\n\t\tscrollBody.scrollLeft = scrollLeft;\n\n\t\tif ( footer ) {\n\t\t\tscrollBody.scrollLeft = scrollLeft;\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(_fnScrollDraw);\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. Correct colgroup > col values if needed\n *   3. Copy colgroup > col over to header and footer\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\tbarWidth       = scroll.iBarWidth,\n\t\tdivHeader      = $(settings.nScrollHead),\n\t\tdivHeaderInner = divHeader.children('div'),\n\t\tdivHeaderTable = divHeaderInner.children('table'),\n\t\tdivBodyEl      = settings.nScrollBody,\n\t\tdivBody        = $(divBodyEl),\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\tfooter         = settings.nTFoot && $('th, td', settings.nTFoot).length ? $(settings.nTFoot) : null,\n\t\tbrowser        = settings.oBrowser,\n\t\theaderCopy, footerCopy;\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// 1. Re-create the table inside the scrolling div\n\t// Remove the old minimised thead and tfoot elements in the inner table\n\ttable.children('thead, tfoot').remove();\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\theaderCopy.find('th, td').removeAttr('tabindex');\n\theaderCopy.find('[id]').removeAttr('id');\n\n\tif ( footer ) {\n\t\tfooterCopy = footer.clone().prependTo( table );\n\t\tfooterCopy.find('[id]').removeAttr('id');\n\t}\n\n\t// 2. Correct colgroup > col values if needed\n\t// It is possible that the cell sizes are smaller than the content, so we need to\n\t// correct colgroup>col for such cases. This can happen if the auto width detection\n\t// uses a cell which has a longer string, but isn't the widest! For example \n\t// \"Chief Executive Officer (CEO)\" is the longest string in the demo, but\n\t// \"Systems Administrator\" is actually the widest string since it doesn't collapse.\n\t// Note the use of translating into a column index to get the `col` element. This\n\t// is because of Responsive which might remove `col` elements, knocking the alignment\n\t// of the indexes out.\n\tif (settings.aiDisplay.length) {\n\t\t// Get the column sizes from the first row in the table. This should really be a\n\t\t// [].find, but it wasn't supported in Chrome until Sept 2015, and DT has 10 year\n\t\t// browser support\n\t\tvar firstTr = null;\n\n\t\tfor (i=0 ; i<settings.aiDisplay.length ; i++) {\n\t\t\tvar idx = settings.aiDisplay[i];\n\t\t\tvar tr = settings.aoData[idx].nTr;\n\n\t\t\tif (tr) {\n\t\t\t\tfirstTr = tr;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\tif (firstTr) {\n\t\t\tvar colSizes = $(firstTr).children('th, td').map(function (vis) {\n\t\t\t\treturn {\n\t\t\t\t\tidx: _fnVisibleToColumnIndex(settings, vis),\n\t\t\t\t\twidth: $(this).outerWidth()\n\t\t\t\t}\n\t\t\t});\n\n\t\t\t// Check against what the colgroup > col is set to and correct if needed\n\t\t\tfor (var i=0 ; i<colSizes.length ; i++) {\n\t\t\t\tvar colEl = settings.aoColumns[ colSizes[i].idx ].colEl[0];\n\t\t\t\tvar colWidth = colEl.style.width.replace('px', '');\n\n\t\t\t\tif (colWidth !== colSizes[i].width) {\n\t\t\t\t\tcolEl.style.width = colSizes[i].width + 'px';\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// 3. Copy the colgroup over to the header and footer\n\tdivHeaderTable\n\t\t.find('colgroup')\n\t\t.remove();\n\n\tdivHeaderTable.append(settings.colgroup.clone());\n\n\tif ( footer ) {\n\t\tdivFooterTable\n\t\t\t.find('colgroup')\n\t\t\t.remove();\n\n\t\tdivFooterTable.append(settings.colgroup.clone());\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.\n\t$('th, td', headerCopy).each(function () {\n\t\t$(this.childNodes).wrapAll('<div class=\"dt-scroll-sizing\">');\n\t});\n\n\tif ( footer ) {\n\t\t$('th, td', footerCopy).each(function () {\n\t\t\t$(this.childNodes).wrapAll('<div class=\"dt-scroll-sizing\">');\n\t\t});\n\t}\n\n\t// 4. Clean up\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 isScrolling = Math.floor(table.height()) > divBodyEl.clientHeight || divBody.css('overflow-y') == \"scroll\";\n\tvar paddingSide = 'padding' + (browser.bScrollbarLeft ? 'Left' : 'Right' );\n\n\t// Set the width's of the header and footer tables\n\tvar outerWidth = table.outerWidth();\n\n\tdivHeaderTable.css('width', _fnStringToCss( outerWidth ));\n\tdivHeaderInner\n\t\t.css('width', _fnStringToCss( outerWidth ))\n\t\t.css(paddingSide, isScrolling ? barWidth+\"px\" : \"0px\");\n\n\tif ( footer ) {\n\t\tdivFooterTable.css('width', _fnStringToCss( outerWidth ));\n\t\tdivFooterInner\n\t\t\t.css('width', _fnStringToCss( outerWidth ))\n\t\t\t.css(paddingSide, isScrolling ? barWidth+\"px\" : \"0px\");\n\t}\n\n\t// Correct DOM ordering for colgroup - comes before the thead\n\ttable.children('colgroup').prependTo(table);\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 * Calculate the width of columns for the table\n *  @param {object} settings dataTables settings object\n *  @memberof DataTable#oApi\n */\nfunction _fnCalculateColumnWidths ( settings )\n{\n\t// Not interested in doing column width calculation if auto-width is disabled\n\tif (! settings.oFeatures.bAutoWidth) {\n\t\treturn;\n\t}\n\n\tvar\n\t\ttable = settings.nTable,\n\t\tcolumns = settings.aoColumns,\n\t\tscroll = settings.oScroll,\n\t\tscrollY = scroll.sY,\n\t\tscrollX = scroll.sX,\n\t\tscrollXInner = scroll.sXInner,\n\t\tvisibleColumns = _fnGetColumns( settings, 'bVisible' ),\n\t\ttableWidthAttr = table.getAttribute('width'), // from DOM element\n\t\ttableContainer = table.parentNode,\n\t\ti, column, columnIdx;\n\t\t\n\tvar styleWidth = table.style.width;\n\n\t// If there is no width applied as a CSS style or as an attribute, we assume that\n\t// the width is intended to be 100%, which is usually is in CSS, but it is very\n\t// difficult to correctly parse the rules to get the final result.\n\tif ( ! styleWidth && ! tableWidthAttr) {\n\t\ttable.style.width = '100%';\n\t\tstyleWidth = '100%';\n\t}\n\n\tif ( styleWidth && styleWidth.indexOf('%') !== -1 ) {\n\t\ttableWidthAttr = styleWidth;\n\t}\n\n\t// Let plug-ins know that we are doing a recalc, in case they have changed any of the\n\t// visible columns their own way (e.g. Responsive uses display:none).\n\t_fnCallbackFire(\n\t\tsettings,\n\t\tnull,\n\t\t'column-calc',\n\t\t{visible: visibleColumns},\n\t\tfalse\n\t);\n\n\t// Construct a single row, worst case, table with the widest\n\t// node in the data, assign any user defined widths, then insert it into\n\t// the DOM and allow the browser to do all the hard work of calculating\n\t// table widths\n\tvar tmpTable = $(table.cloneNode())\n\t\t.css( 'visibility', 'hidden' )\n\t\t.removeAttr( 'id' );\n\n\t// Clean up the table body\n\ttmpTable.append('<tbody>')\n\tvar tr = $('<tr/>').appendTo( tmpTable.find('tbody') );\n\n\t// Clone the table header and footer - we can't use the header / footer\n\t// from the cloned table, since if scrolling is active, the table's\n\t// real header and footer are contained in different table tags\n\ttmpTable\n\t\t.append( $(settings.nTHead).clone() )\n\t\t.append( $(settings.nTFoot).clone() );\n\n\t// Remove any assigned widths from the footer (from scrolling)\n\ttmpTable.find('tfoot th, tfoot td').css('width', '');\n\n\t// Apply custom sizing to the cloned header\n\ttmpTable.find('thead th, thead td').each( function () {\n\t\t// Get the `width` from the header layout\n\t\tvar width = _fnColumnsSumWidth( settings, this, true, false );\n\n\t\tif ( width ) {\n\t\t\t// Need to set the width and min-width, otherwise the browser\n\t\t\t// will attempt to collapse the table beyond want might have\n\t\t\t// been specified\n\t\t\tthis.style.width = width;\n\t\t\tthis.style.minWidth = width;\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 ( scrollX ) {\n\t\t\t\t$( this ).append( $('<div/>').css( {\n\t\t\t\t\twidth: width,\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\t\telse {\n\t\t\tthis.style.width = '';\n\t\t}\n\t} );\n\n\t// Find the widest piece of data for each column and put it into the table\n\tfor ( i=0 ; i<visibleColumns.length ; i++ ) {\n\t\tcolumnIdx = visibleColumns[i];\n\t\tcolumn = columns[ columnIdx ];\n\n\t\tvar longest = _fnGetMaxLenString(settings, columnIdx);\n\t\tvar autoClass = _ext.type.className[column.sType];\n\t\tvar text = longest + column.sContentPadding;\n\t\tvar insert = longest.indexOf('<') === -1\n\t\t\t? document.createTextNode(text)\n\t\t\t: text\n\t\t\n\t\t$('<td/>')\n\t\t\t.addClass(autoClass)\n\t\t\t.addClass(column.sClass)\n\t\t\t.append(insert)\n\t\t\t.appendTo(tr);\n\t}\n\n\t// Tidy the temporary table - remove name attributes so there aren't\n\t// duplicated in the dom (radio elements for example)\n\t$('[name]', tmpTable).removeAttr('name');\n\n\t// Table has been built, attach to the document so we can work with it.\n\t// A holding element is used, positioned at the top of the container\n\t// with minimal height, so it has no effect on if the container scrolls\n\t// or not. Otherwise it might trigger scrolling when it actually isn't\n\t// needed\n\tvar holder = $('<div/>').css( scrollX || scrollY ?\n\t\t\t{\n\t\t\t\tposition: 'absolute',\n\t\t\t\ttop: 0,\n\t\t\t\tleft: 0,\n\t\t\t\theight: 1,\n\t\t\t\tright: 0,\n\t\t\t\toverflow: 'hidden'\n\t\t\t} :\n\t\t\t{}\n\t\t)\n\t\t.append( tmpTable )\n\t\t.appendTo( tableContainer );\n\n\t// When scrolling (X or Y) we want to set the width of the table as \n\t// appropriate. However, when not scrolling leave the table width as it\n\t// is. This results in slightly different, but I think correct behaviour\n\tif ( scrollX && scrollXInner ) {\n\t\ttmpTable.width( scrollXInner );\n\t}\n\telse if ( scrollX ) {\n\t\ttmpTable.css( 'width', 'auto' );\n\t\ttmpTable.removeAttr('width');\n\n\t\t// If there is no width attribute or style, then allow the table to\n\t\t// collapse\n\t\tif ( tmpTable.width() < tableContainer.clientWidth && tableWidthAttr ) {\n\t\t\ttmpTable.width( tableContainer.clientWidth );\n\t\t}\n\t}\n\telse if ( scrollY ) {\n\t\ttmpTable.width( tableContainer.clientWidth );\n\t}\n\telse if ( tableWidthAttr ) {\n\t\ttmpTable.width( tableWidthAttr );\n\t}\n\n\t// Get the width of each column in the constructed table\n\tvar total = 0;\n\tvar bodyCells = tmpTable.find('tbody tr').eq(0).children();\n\n\tfor ( i=0 ; i<visibleColumns.length ; i++ ) {\n\t\t// Use getBounding for sub-pixel accuracy, which we then want to round up!\n\t\tvar bounding = bodyCells[i].getBoundingClientRect().width;\n\n\t\t// Total is tracked to remove any sub-pixel errors as the outerWidth\n\t\t// of the table might not equal the total given here\n\t\ttotal += bounding;\n\n\t\t// Width for each column to use\n\t\tcolumns[ visibleColumns[i] ].sWidth = _fnStringToCss( bounding );\n\t}\n\n\ttable.style.width = _fnStringToCss( total );\n\n\t// Finished with the table - ditch it\n\tholder.remove();\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) && ! settings._reszEvt ) {\n\t\tvar bindResize = function () {\n\t\t\t$(window).on('resize.DT-'+settings.sInstance, DataTable.util.throttle( function () {\n\t\t\t\tif (! settings.bDestroying) {\n\t\t\t\t\t_fnAdjustColumnSizing( settings );\n\t\t\t\t}\n\t\t\t} ) );\n\t\t};\n\n\t\tbindResize();\n\n\t\tsettings._reszEvt = true;\n\t}\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} string of the max length\n *  @memberof DataTable#oApi\n */\nfunction _fnGetMaxLenString( settings, colIdx )\n{\n\tvar column = settings.aoColumns[colIdx];\n\n\tif (! column.maxLenString) {\n\t\tvar s, max='', maxLen = -1;\n\t\n\t\tfor ( var i=0, ien=settings.aiDisplayMaster.length ; i<ien ; i++ ) {\n\t\t\tvar rowIdx = settings.aiDisplayMaster[i];\n\t\t\tvar data = _fnGetRowDisplay(settings, rowIdx)[colIdx];\n\n\t\t\tvar cellString = data && typeof data === 'object' && data.nodeType\n\t\t\t\t? data.innerHTML\n\t\t\t\t: data+'';\n\n\t\t\t// Remove id / name attributes from elements so they\n\t\t\t// don't interfere with existing elements\n\t\t\tcellString = cellString\n\t\t\t\t.replace(/id=\".*?\"/g, '')\n\t\t\t\t.replace(/name=\".*?\"/g, '');\n\n\t\t\ts = _stripHtml(cellString)\n\t\t\t\t.replace( /&nbsp;/g, ' ' );\n\t\n\t\t\tif ( s.length > maxLen ) {\n\t\t\t\t// We want the HTML in the string, but the length that\n\t\t\t\t// is important is the stripped string\n\t\t\t\tmax = cellString;\n\t\t\t\tmaxLen = s.length;\n\t\t\t}\n\t\t}\n\n\t\tcolumn.maxLenString = max;\n\t}\n\n\treturn column.maxLenString;\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 * Re-insert the `col` elements for current visibility\n *\n * @param {*} settings DT settings\n */\nfunction _colGroup( settings ) {\n\tvar cols = settings.aoColumns;\n\n\tsettings.colgroup.empty();\n\n\tfor (i=0 ; i<cols.length ; i++) {\n\t\tif (cols[i].bVisible) {\n\t\t\tsettings.colgroup.append(cols[i].colEl);\n\t\t}\n\t}\n}\n\n\nfunction _fnSortInit( settings ) {\n\tvar target = settings.nTHead;\n\tvar headerRows = target.querySelectorAll('tr');\n\tvar legacyTop = settings.bSortCellsTop;\n\tvar notSelector = ':not([data-dt-order=\"disable\"]):not([data-dt-order=\"icon-only\"])';\n\t\n\t// Legacy support for `orderCellsTop`\n\tif (legacyTop === true) {\n\t\ttarget = headerRows[0];\n\t}\n\telse if (legacyTop === false) {\n\t\ttarget = headerRows[ headerRows.length - 1 ];\n\t}\n\n\t_fnSortAttachListener(\n\t\tsettings,\n\t\ttarget,\n\t\ttarget === settings.nTHead\n\t\t\t? 'tr'+notSelector+' th'+notSelector+', tr'+notSelector+' td'+notSelector\n\t\t\t: 'th'+notSelector+', td'+notSelector\n\t);\n\n\t// Need to resolve the user input array into our internal structure\n\tvar order = [];\n\t_fnSortResolve( settings, order, settings.aaSorting );\n\n\tsettings.aaSorting = order;\n}\n\n\nfunction _fnSortAttachListener(settings, node, selector, column, callback) {\n\t_fnBindAction( node, selector, function (e) {\n\t\tvar run = false;\n\t\tvar columns = column === undefined\n\t\t\t? _fnColumnsFromHeader( e.target )\n\t\t\t: [column];\n\n\t\tif ( columns.length ) {\n\t\t\tfor ( var i=0, ien=columns.length ; i<ien ; i++ ) {\n\t\t\t\tvar ret = _fnSortAdd( settings, columns[i], i, e.shiftKey );\n\n\t\t\t\tif (ret !== false) {\n\t\t\t\t\trun = true;\n\t\t\t\t}\t\t\t\t\t\n\n\t\t\t\t// If the first entry is no sort, then subsequent\n\t\t\t\t// sort columns are ignored\n\t\t\t\tif (settings.aaSorting.length === 1 && settings.aaSorting[0][1] === '') {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (run) {\n\t\t\t\t_fnProcessingRun(settings, true, function () {\n\t\t\t\t\t_fnSort( settings );\n\t\t\t\t\t_fnSortDisplay( settings, settings.aiDisplay );\n\n\t\t\t\t\t_fnReDraw( settings, false, false );\n\n\t\t\t\t\tif (callback) {\n\t\t\t\t\t\tcallback();\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t} );\n}\n\n/**\n * Sort the display array to match the master's order\n * @param {*} settings\n */\nfunction _fnSortDisplay(settings, display) {\n\tif (display.length < 2) {\n\t\treturn;\n\t}\n\n\tvar master = settings.aiDisplayMaster;\n\tvar masterMap = {};\n\tvar map = {};\n\tvar i;\n\n\t// Rather than needing an `indexOf` on master array, we can create a map\n\tfor (i=0 ; i<master.length ; i++) {\n\t\tmasterMap[master[i]] = i;\n\t}\n\n\t// And then cache what would be the indexOf fom the display\n\tfor (i=0 ; i<display.length ; i++) {\n\t\tmap[display[i]] = masterMap[display[i]];\n\t}\n\n\tdisplay.sort(function(a, b){\n\t\t// Short version of this function is simply `master.indexOf(a) - master.indexOf(b);`\n\t\treturn map[a] - map[b];\n\t});\n}\n\n\nfunction _fnSortResolve (settings, nestedSort, sort) {\n\tvar push = function ( a ) {\n\t\tif ($.isPlainObject(a)) {\n\t\t\tif (a.idx !== undefined) {\n\t\t\t\t// Index based ordering\n\t\t\t\tnestedSort.push([a.idx, a.dir]);\n\t\t\t}\n\t\t\telse if (a.name) {\n\t\t\t\t// Name based ordering\n\t\t\t\tvar cols = _pluck( settings.aoColumns, 'sName');\n\t\t\t\tvar idx = cols.indexOf(a.name);\n\n\t\t\t\tif (idx !== -1) {\n\t\t\t\t\tnestedSort.push([idx, a.dir]);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\telse {\n\t\t\t// Plain column index and direction pair\n\t\t\tnestedSort.push(a);\n\t\t}\n\t};\n\n\tif ( $.isPlainObject(sort) ) {\n\t\t// Object\n\t\tpush(sort);\n\t}\n\telse if ( sort.length && typeof sort[0] === 'number' ) {\n\t\t// 1D array\n\t\tpush(sort);\n\t}\n\telse if ( sort.length ) {\n\t\t// 2D array\n\t\tfor (var z=0; z<sort.length; z++) {\n\t\t\tpush(sort[z]); // Object or array\n\t\t}\n\t}\n}\n\n\nfunction _fnSortFlatten ( settings )\n{\n\tvar\n\t\ti, k, kLen,\n\t\taSort = [],\n\t\textSort = DataTable.ext.type.order,\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\n\tif ( ! settings.oFeatures.bSort ) {\n\t\treturn aSort;\n\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\t_fnSortResolve( settings, nestedSort, fixed );\n\t}\n\n\tif ( fixedObj && fixed.pre ) {\n\t\t_fnSortResolve( settings, nestedSort, fixed.pre );\n\t}\n\n\t_fnSortResolve( settings, nestedSort, settings.aaSorting );\n\n\tif (fixedObj && fixed.post ) {\n\t\t_fnSortResolve( settings, nestedSort, fixed.post );\n\t}\n\n\tfor ( i=0 ; i<nestedSort.length ; i++ )\n\t{\n\t\tsrcCol = nestedSort[i][0];\n\n\t\tif ( aoColumns[ srcCol ] ) {\n\t\t\taDataSort = aoColumns[ srcCol ].aDataSort;\n\n\t\t\tfor ( k=0, kLen=aDataSort.length ; k<kLen ; k++ )\n\t\t\t{\n\t\t\t\tiCol = aDataSort[k];\n\t\t\t\tsType = aoColumns[ iCol ].sType || 'string';\n\n\t\t\t\tif ( nestedSort[i]._idx === undefined ) {\n\t\t\t\t\tnestedSort[i]._idx = aoColumns[iCol].asSorting.indexOf(nestedSort[i][1]);\n\t\t\t\t}\n\n\t\t\t\tif ( nestedSort[i][1] ) {\n\t\t\t\t\taSort.push( {\n\t\t\t\t\t\tsrc:       srcCol,\n\t\t\t\t\t\tcol:       iCol,\n\t\t\t\t\t\tdir:       nestedSort[i][1],\n\t\t\t\t\t\tindex:     nestedSort[i]._idx,\n\t\t\t\t\t\ttype:      sType,\n\t\t\t\t\t\tformatter: extSort[ sType+\"-pre\" ],\n\t\t\t\t\t\tsorter:    extSort[ sType+\"-\"+nestedSort[i][1] ]\n\t\t\t\t\t} );\n\t\t\t\t}\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 */\nfunction _fnSort ( oSettings, col, dir )\n{\n\tvar\n\t\ti, ien, iLen,\n\t\taiOrig = [],\n\t\textSort = DataTable.ext.type.order,\n\t\taoData = oSettings.aoData,\n\t\tsortCol,\n\t\tdisplayMaster = oSettings.aiDisplayMaster,\n\t\taSort;\n\n\t// Allow a specific column to be sorted, which will _not_ alter the display\n\t// master\n\tif (col !== undefined) {\n\t\tvar srcCol = oSettings.aoColumns[col];\n\t\taSort = [{\n\t\t\tsrc:       col,\n\t\t\tcol:       col,\n\t\t\tdir:       dir,\n\t\t\tindex:     0,\n\t\t\ttype:      srcCol.sType,\n\t\t\tformatter: extSort[ srcCol.sType+\"-pre\" ],\n\t\t\tsorter:    extSort[ srcCol.sType+\"-\"+dir ]\n\t\t}];\n\t\tdisplayMaster = displayMaster.slice();\n\t}\n\telse {\n\t\taSort = _fnSortFlatten( oSettings );\n\t}\n\n\tfor ( i=0, ien=aSort.length ; i<ien ; i++ ) {\n\t\tsortCol = aSort[i];\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// Reset the initial positions on each pass so we get a stable sort\n\t\tfor ( i=0, iLen=displayMaster.length ; i<iLen ; i++ ) {\n\t\t\taiOrig[ i ] = i;\n\t\t}\n\n\t\t// If the first sort is desc, then reverse the array to preserve original\n\t\t// order, just in reverse\n\t\tif (aSort.length && aSort[0].dir === 'desc' && oSettings.orderDescReverse) {\n\t\t\taiOrig.reverse();\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 test;\n\t\t *    test = oSort['string-asc']('data11', 'data12');\n\t\t *      if (test !== 0)\n\t\t *        return test;\n\t\t *    test = oSort['numeric-desc']('data21', 'data22');\n\t\t *    if (test !== 0)\n\t\t *      return test;\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\tdisplayMaster.sort( function ( a, b ) {\n\t\t\tvar\n\t\t\t\tx, y, k, test, sort,\n\t\t\t\tlen=aSort.length,\n\t\t\t\tdataA = aoData[a]._aSortData,\n\t\t\t\tdataB = aoData[b]._aSortData;\n\n\t\t\tfor ( k=0 ; k<len ; k++ ) {\n\t\t\t\tsort = aSort[k];\n\n\t\t\t\t// Data, which may have already been through a `-pre` function\n\t\t\t\tx = dataA[ sort.col ];\n\t\t\t\ty = dataB[ sort.col ];\n\n\t\t\t\tif (sort.sorter) {\n\t\t\t\t\t// If there is a custom sorter (`-asc` or `-desc`) for this\n\t\t\t\t\t// data type, use it\n\t\t\t\t\ttest = sort.sorter(x, y);\n\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\t\t\t\telse {\n\t\t\t\t\t// Otherwise, use generic sorting\n\t\t\t\t\ttest = x<y ? -1 : x>y ? 1 : 0;\n\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\t\t\t}\n\n\t\t\tx = aiOrig[a];\n\t\t\ty = aiOrig[b];\n\n\t\t\treturn x<y ? -1 : x>y ? 1 : 0;\n\t\t} );\n\t}\n\telse if ( aSort.length === 0 ) {\n\t\t// Apply index order\n\t\tdisplayMaster.sort(function (x, y) {\n\t\t\treturn x<y ? -1 : x>y ? 1 : 0;\n\t\t});\n\t}\n\n\tif (col === undefined) {\n\t\t// Tell the draw function that we have sorted the data\n\t\toSettings.bSorted = true;\n\t\toSettings.sortDetails = aSort;\n\n\t\t_fnCallbackFire( oSettings, null, 'order', [oSettings, aSort] );\n\t}\n\n\treturn displayMaster;\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 {int} addIndex Counter\n *  @param {boolean} [shift=false] Shift click add\n *  @param {function} [callback] callback function\n *  @memberof DataTable#oApi\n */\nfunction _fnSortAdd ( settings, colIdx, addIndex, shift )\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 = asSorting.indexOf(a[1]);\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\tif ( ! col.bSortable ) {\n\t\treturn false;\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 ( (shift || addIndex) && settings.oFeatures.bSortMulti ) {\n\t\t// Are we already doing some kind of sort on this column?\n\t\tvar sortIdx = _pluck(sorting, '0').indexOf(colIdx);\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 if (shift) {\n\t\t\t// No sort on this column yet, being added by shift click\n\t\t\t// add it as itself\n\t\t\tsorting.push( [ colIdx, asSorting[0], 0 ] );\n\t\t\tsorting[sorting.length-1]._idx = 0;\n\t\t}\n\t\telse {\n\t\t\t// No sort on this column yet, being added from a colspan\n\t\t\t// so add with same direction as first column\n\t\t\tsorting.push( [ colIdx, sorting[0][1], 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\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.order.position;\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, colIdx )\n{\n\t// Custom sorting function - provided by the sort data type\n\tvar column = settings.aoColumns[ colIdx ];\n\tvar customSort = DataTable.ext.order[ column.sSortDataType ];\n\tvar customData;\n\n\tif ( customSort ) {\n\t\tcustomData = customSort.call( settings.oInstance, settings, colIdx,\n\t\t\t_fnColumnIndexToVisible( settings, colIdx )\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\tvar data = settings.aoData;\n\n\tfor ( var rowIdx=0 ; rowIdx<data.length ; rowIdx++ ) {\n\t\t// Sparse array\n\t\tif (! data[rowIdx]) {\n\t\t\tcontinue;\n\t\t}\n\n\t\trow = data[rowIdx];\n\n\t\tif ( ! row._aSortData ) {\n\t\t\trow._aSortData = [];\n\t\t}\n\n\t\tif ( ! row._aSortData[colIdx] || customSort ) {\n\t\t\tcellData = customSort ?\n\t\t\t\tcustomData[rowIdx] : // If there was a custom sort function, use data from there\n\t\t\t\t_fnGetCellData( settings, rowIdx, colIdx, 'sort' );\n\n\t\t\trow._aSortData[ colIdx ] = formatter ?\n\t\t\t\tformatter( cellData, settings ) :\n\t\t\t\tcellData;\n\t\t}\n\t}\n}\n\n\n/**\n * State information for a table\n *\n * @param {*} settings\n * @returns State object\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:  $.extend({}, settings.oPreviousSearch),\n\t\tcolumns: settings.aoColumns.map( function ( col, i ) {\n\t\t\treturn {\n\t\t\t\tvisible: col.bVisible,\n\t\t\t\tsearch: $.extend({}, 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, init, 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// 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// 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 ( abStateLoad.indexOf(false) !== -1 ) {\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// This is needed for ColReorder, which has to happen first to allow all\n\t// the stored indexes to be usable. It is not publicly documented.\n\t_fnCallbackFire( settings, null, 'stateLoadInit', [settings, s], true );\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\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, 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], 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 * 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, 'dt-error', [ settings, tn, msg ], true );\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 ( Object.prototype.hasOwnProperty.call(extender, 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|string} selector Selector (for delegated events) or data object\n *   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, selector, fn )\n{\n\t$(n)\n\t\t.on( 'click.DT', selector, function (e) {\n\t\t\tfn(e);\n\t\t} )\n\t\t.on( 'keypress.DT', selector, function (e){\n\t\t\tif ( e.which === 13 ) {\n\t\t\t\te.preventDefault();\n\t\t\t\tfn(e);\n\t\t\t}\n\t\t} )\n\t\t.on( 'selectstart.DT', selector, function () {\n\t\t\t// Don't want a double click resulting in text selection\n\t\t\treturn false;\n\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} settings dataTables settings object\n *  @param {string} store Name of the array storage for the callbacks in oSettings\n *  @param {function} fn Function to be called back\n *  @memberof DataTable#oApi\n */\nfunction _fnCallbackReg( settings, store, fn )\n{\n\tif ( fn ) {\n\t\tsettings[store].push(fn);\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 *  @param {boolean} [bubbles] True if the event should bubble\n *  @memberof DataTable#oApi\n */\nfunction _fnCallbackFire( settings, callbackArr, eventName, args, bubbles )\n{\n\tvar ret = [];\n\n\tif ( callbackArr ) {\n\t\tret = settings[callbackArr].slice().reverse().map( function (val) {\n\t\t\treturn val.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\t\t\n\t\t// Expose the DataTables API on the event object for easy access\n\t\te.dt = settings.api;\n\n\t\ttable[bubbles ?  'trigger' : 'triggerHandler']( 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 (bubbles && 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 ) {\n\t\treturn 'ajax';\n\t}\n\treturn 'dom';\n}\n\n/**\n * Common replacement for language strings\n *\n * @param {*} settings DT settings object\n * @param {*} str String with values to replace\n * @param {*} entries Plural number for _ENTRIES_ - can be undefined\n * @returns String\n */\nfunction _fnMacros ( settings, str, entries )\n{\n\t// When infinite scrolling, we are always starting at 1. _iDisplayStart is\n\t// used only 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\tmax        = settings.fnRecordsTotal(),\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, max ) ).\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\t\treplace(/_ENTRIES_/g, settings.api.i18n('entries', '', entries) ).\n\t\treplace(/_ENTRIES-MAX_/g, settings.api.i18n('entries', '', max) ).\n\t\treplace(/_ENTRIES-TOTAL_/g, settings.api.i18n('entries', '', vis) );\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 = _pluck(settings, 'nTable');\n\n\tif ( ! mixed ) {\n\t\treturn [];\n\t}\n\telse if ( mixed.nTable && mixed.oFeatures ) {\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 = tables.indexOf(mixed);\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).get();\n\t}\n\telse if ( mixed instanceof $ ) {\n\t\t// jQuery object (also DataTables instance)\n\t\tjq = mixed.get();\n\t}\n\n\tif ( jq ) {\n\t\treturn settings.filter(function (v, idx) {\n\t\t\treturn jq.includes(tables[idx]);\n\t\t});\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 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 i;\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 ( i=0 ; i<context.length ; 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 = settings.length > 1\n\t\t? _unique( settings )\n\t\t: settings;\n\n\t// Initial data\n\tif ( data ) {\n\t\t// Chrome can throw a max stack error if apply is called with\n\t\t// too large an array, but apply is faster.\n\t\tif (data.length < 10000) {\n\t\t\tthis.push.apply(this, data);\n\t\t}\n\t\telse {\n\t\t\tfor (i=0 ; i<data.length ; i++) {\n\t\t\t\tthis.push(data[i]);\n\t\t\t}\n\t\t}\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\tcontext: [], // array of table settings objects\n\n\tcount: function ()\n\t{\n\t\treturn this.flatten().length;\n\t},\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\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\tfilter: function ( fn )\n\t{\n\t\tvar a = __arrayProto.filter.call( this, fn, this );\n\n\t\treturn new _Api( this.context, a );\n\t},\n\n\tflatten: function ()\n\t{\n\t\tvar a = [];\n\n\t\treturn new _Api( this.context, a.concat.apply( a, this.toArray() ) );\n\t},\n\n\tget: function ( idx )\n\t{\n\t\treturn this[ idx ];\n\t},\n\n\tjoin:    __arrayProto.join,\n\n\tincludes: function ( find ) {\n\t\treturn this.indexOf( find ) === -1 ? false : true;\n\t},\n\n\tindexOf: __arrayProto.indexOf,\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 === 'every' || 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\tlastIndexOf: __arrayProto.lastIndexOf,\n\n\tlength:  0,\n\n\tmap: function ( fn )\n\t{\n\t\tvar a = __arrayProto.map.call( this, fn, this );\n\n\t\treturn new _Api( this.context, a );\n\t},\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\tpush:    __arrayProto.push,\n\n\treduce: __arrayProto.reduce,\n\n\treduceRight: __arrayProto.reduceRight,\n\n\treverse: __arrayProto.reverse,\n\n\t// Object with rows, columns and opts\n\tselector: null,\n\n\tshift:   __arrayProto.shift,\n\n\tslice: function () {\n\t\treturn new _Api( this.context, this );\n\t},\n\n\tsort:    __arrayProto.sort,\n\n\tsplice:  __arrayProto.splice,\n\n\ttoArray: function ()\n\t{\n\t\treturn __arrayProto.slice.call( this );\n\t},\n\n\tto$: function ()\n\t{\n\t\treturn $( this );\n\t},\n\n\ttoJQuery: function ()\n\t{\n\t\treturn $( this );\n\t},\n\n\tunique: function ()\n\t{\n\t\treturn new _Api( this.context, _unique(this.toArray()) );\n\t},\n\n\tunshift: __arrayProto.unshift\n} );\n\n\nfunction _api_scope( scope, fn, struc ) {\n\treturn function () {\n\t\tvar ret = fn.apply( scope || this, arguments );\n\n\t\t// Method extension\n\t\t_Api.extend( ret, ret, struc.methodExt );\n\t\treturn ret;\n\t};\n}\n\nfunction _api_find( src, name ) {\n\tfor ( var i=0, ien=src.length ; i<ien ; i++ ) {\n\t\tif ( src[i].name === name ) {\n\t\t\treturn src[i];\n\t\t}\n\t}\n\treturn null;\n}\n\nwindow.__apiStruct = __apiStruct;\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\n\tfor ( i=0, ien=ext.length ; i<ien ; i++ ) {\n\t\tstruct = ext[i];\n\n\t\tif (struct.name === '__proto__') {\n\t\t\tcontinue;\n\t\t}\n\n\t\t// Value\n\t\tobj[ struct.name ] = struct.type === 'function' ?\n\t\t\t_api_scope( 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//       {\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\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\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 = _api_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\tvar result = [];\n\n\t\tselector.forEach(function (sel) {\n\t\t\tvar inner = __table_selector(sel, a);\n\n\t\t\tresult.push.apply(result, inner);\n\t\t});\n\n\t\treturn result.filter( function (item) {\n\t\t\treturn item;\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 = a.map( function (el) {\n\t\treturn el.nTable;\n\t} );\n\n\treturn $(nodes)\n\t\t.filter( selector )\n\t\t.map( function () {\n\t\t\t// Need to translate back from the table node to the settings\n\t\t\tvar idx = nodes.indexOf(this);\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// Common methods, combined to reduce size\n[\n\t['nodes', 'node', 'nTable'],\n\t['body', 'body', 'nTBody'],\n\t['header', 'header', 'nTHead'],\n\t['footer', 'footer', 'nTFoot'],\n].forEach(function (item) {\n\t_api_registerPlural(\n\t\t'tables().' + item[0] + '()',\n\t\t'table().' + item[1] + '()' ,\n\t\tfunction () {\n\t\t\treturn this.iterator( 'table', function ( ctx ) {\n\t\t\t\treturn ctx[item[2]];\n\t\t\t}, 1 );\n\t\t}\n\t);\n});\n\n// Structure methods\n[\n\t['header', 'aoHeader'],\n\t['footer', 'aoFooter'],\n].forEach(function (item) {\n\t_api_register( 'table().' + item[0] + '.structure()' , function (selector) {\n\t\tvar indexes = this.columns(selector).indexes().flatten();\n\t\tvar ctx = this.context[0];\n\t\t\n\t\treturn _fnHeaderLayout(ctx, ctx[item[1]], indexes);\n\t} );\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_api_register( 'tables().every()', function ( fn ) {\n\tvar that = this;\n\n\treturn this.iterator('table', function (s, i) {\n\t\tfn.call(that.table(i), i);\n\t});\n});\n\n_api_register( 'caption()', function ( value, side ) {\n\tvar context = this.context;\n\n\t// Getter - return existing node's content\n\tif ( value === undefined ) {\n\t\tvar caption = context[0].captionNode;\n\n\t\treturn caption && context.length ?\n\t\t\tcaption.innerHTML : \n\t\t\tnull;\n\t}\n\n\treturn this.iterator( 'table', function ( ctx ) {\n\t\tvar table = $(ctx.nTable);\n\t\tvar caption = $(ctx.captionNode);\n\t\tvar container = $(ctx.nTableWrapper);\n\n\t\t// Create the node if it doesn't exist yet\n\t\tif ( ! caption.length ) {\n\t\t\tcaption = $('<caption/>').html( value );\n\t\t\tctx.captionNode = caption[0];\n\n\t\t\t// If side isn't set, we need to insert into the document to let the\n\t\t\t// CSS decide so we can read it back, otherwise there is no way to\n\t\t\t// know if the CSS would put it top or bottom for scrolling\n\t\t\tif (! side) {\n\t\t\t\ttable.prepend(caption);\n\n\t\t\t\tside = caption.css('caption-side');\n\t\t\t}\n\t\t}\n\n\t\tcaption.html( value );\n\n\t\tif ( side ) {\n\t\t\tcaption.css( 'caption-side', side );\n\t\t\tcaption[0]._captionSide = side;\n\t\t}\n\n\t\tif (container.find('div.dataTables_scroll').length) {\n\t\t\tvar selector = (side === 'top' ? 'Head' : 'Foot');\n\n\t\t\tcontainer.find('div.dataTables_scroll'+ selector +' table').prepend(caption);\n\t\t}\n\t\telse {\n\t\t\ttable.prepend(caption);\n\t\t}\n\t}, 1 );\n} );\n\n_api_register( 'caption.node()', function () {\n\tvar ctx = this.context;\n\n\treturn ctx.length ? ctx[0].captionNode : null;\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 () {\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_fnInitComplete( settings );\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 $.isPlainObject( ctx.ajax ) ?\n\t\t\tctx.ajax.url :\n\t\t\tctx.ajax;\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} );\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\t// Remove empty items\n\t\t\tres = res.filter( function (item) {\n\t\t\t\treturn item !== null && item !== undefined;\n\t\t\t});\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\n// Reduce the API instance to the first item found\nvar _selector_first = function ( old )\n{\n\tlet inst = new _Api(old.context[0]);\n\n\t// Use a push rather than passing to the constructor, since it will\n\t// merge arrays down automatically, which isn't what is wanted here\n\tif (old.length) {\n\t\tinst.push( old[0] );\n\t}\n\n\tinst.selector = old.selector;\n\n\t// Limit to a single row / column / cell\n\tif (inst.length && inst[0].length > 1) {\n\t\tinst[0].splice(1);\n\t}\n\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\n\tif ( 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 ( i=0, ien=displayFiltered.length ; i<ien ; i++ ) {\n\t\t\t\tdisplayFilteredMap[displayFiltered[i]] = null;\n\t\t\t}\n\n\t\t\tdisplayMaster.forEach(function (item) {\n\t\t\t\tif (! Object.prototype.hasOwnProperty.call(displayFilteredMap, item)) {\n\t\t\t\t\ta.push(item);\n\t\t\t\t}\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 (! settings.aoData[i]) {\n\t\t\t\tcontinue;\n\t\t\t}\n\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 = displayFiltered.indexOf(i);\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\telse if ( typeof order === 'number' ) {\n\t\t// Order the rows by the given column\n\t\tvar ordered = _fnSort(settings, order, 'asc');\n\n\t\tif (search === 'none') {\n\t\t\ta = ordered;\n\t\t}\n\t\telse { // applied | removed\n\t\t\tfor (i=0; i<ordered.length; i++) {\n\t\t\t\ttmp = displayFiltered.indexOf(ordered[i]);\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( ordered[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 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 && rows.indexOf(selInt) !== -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 rows.map( 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\tvar matched = _selector_run( 'row', selector, run, settings, opts );\n\n\tif (opts.order === 'current' || opts.order === 'applied') {\n\t\t_fnSortDisplay(settings, matched);\n\t}\n\n\treturn matched;\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\tthis.iterator( 'row', function ( settings, row ) {\n\t\tvar data = settings.aoData;\n\t\tvar rowData = data[ row ];\n\n\t\t// Delete from the display arrays\n\t\tvar idx = settings.aiDisplayMaster.indexOf(row);\n\t\tif (idx !== -1) {\n\t\t\tsettings.aiDisplayMaster.splice(idx, 1);\n\t\t}\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\n\t\tdata[row] = null;\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\tmodRows.push.apply(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 && this[0].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\tif (ctx.length && this.length && this[0].length) {\n\t\tvar row = ctx[0].aoData[ this[0] ];\n\n\t\tif (row && row.nTr) {\n\t\t\treturn row.nTr;\n\t\t}\n\t}\n\n\treturn null;\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\n\tapi.on( 'stateSaveParams.DT', 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 rows = settings.aiDisplayMaster;\n\t\tvar ids = [];\n\n\t\tfor (var i=0 ; i<rows.length ; i++) {\n\t\t\tvar rowIdx = rows[i];\n\t\t\tvar data = settings.aoData[rowIdx];\n\n\t\t\tif (data._detailsShow) {\n\t\t\t\tids.push( '#' + idFn(data._aData) );\n\t\t\t}\n\t\t}\n\n\t\td.childRows = ids;\n\t});\n\n\t// For future state loads (e.g. with StateRestore)\n\tapi.on( 'stateLoaded.DT', function (e, settings, state) {\n\t\t__details_state_load( api, state );\n\t});\n\n\t// And the initial load state\n\t__details_state_load( api, api.state.loaded() );\n});\n\nvar __details_state_load = function (api, state)\n{\n\tif ( state && state.childRows ) {\n\t\tapi\n\t\t\t.rows( state.childRows.map(function (id) {\n\t\t\t\t// Escape any `:` characters from the row id. Accounts for\n\t\t\t\t// already escaped characters.\n\t\t\t\treturn id.replace(/([^:\\\\]*(?:\\\\.[^:\\\\]*)*):/g, \"$1\\\\:\");\n\t\t\t}) )\n\t\t\t.every( function () {\n\t\t\t\t_fnCallbackFire( api.settings()[0], 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\tr.setAttribute( 'data-dt-row', row.idx );\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>')\n\t\t\t\t.attr( 'data-dt-row', row.idx )\n\t\t\t\t.addClass( k );\n\t\t\t\n\t\t\t$('td', created)\n\t\t\t\t.addClass( k )\n\t\t\t\t.html( r )[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 ) {\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 && 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] && 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 && ctx[0].aoData[ this[0] ]\n\t\t\t? ctx[0].aoData[ this[0] ]._details\n\t\t\t: undefined;\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 () {         // 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 && ctx[0].aoData[ this[0] ] ) {\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|title|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, type ) {\n\tvar a = [];\n\tfor ( var row=0, ien=rows.length ; row<ien ; row++ ) {\n\t\ta.push( _fnGetCellData( settings, rows[row], column, type ) );\n\t}\n\treturn a;\n};\n\n\nvar __column_header = function ( settings, column, row ) {\n\tvar header = settings.aoHeader;\n\tvar target = row !== undefined\n\t\t? row\n\t\t: settings.bSortCellsTop // legacy support\n\t\t\t? 0\n\t\t\t: header.length - 1;\n\n\treturn header[target][column].cell;\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\ttitles = _pluck( columns, 'sTitle' ),\n\t\tcells = DataTable.util.get('[].[].cell')(settings.aoHeader),\n\t\tnodes = _unique( _flatten([], cells) );\n\t\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 columns.map(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\t__column_header( settings, 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\t// Selector is a column index\n\t\t\t\t\tif (match[1] && match[1].match(/^\\d+$/)) {\n\t\t\t\t\t\tvar idx = parseInt( match[1], 10 );\n\n\t\t\t\t\t\t// Visible index given, convert to column index\n\t\t\t\t\t\tif ( idx < 0 ) {\n\t\t\t\t\t\t\t// Counting from the right\n\t\t\t\t\t\t\tvar visColumns = columns.map( function (col,i) {\n\t\t\t\t\t\t\t\treturn col.bVisible ? i : null;\n\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t\treturn [ visColumns[ visColumns.length + idx ] ];\n\t\t\t\t\t\t}\n\t\t\t\t\t\t// Counting from the left\n\t\t\t\t\t\treturn [ _fnVisibleToColumnIndex( settings, idx ) ];\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t\treturn columns.map( function (col, idx) {\n\t\t\t\t\t\t// Not visible, can't match\n\t\t\t\t\t\tif (! col.bVisible) {\n\t\t\t\t\t\t\treturn null;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Selector\n\t\t\t\t\t\tif (match[1]) {\n\t\t\t\t\t\t\treturn $(nodes[idx]).filter(match[1]).length > 0 ? idx : null;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// `:visible` on its own\n\t\t\t\t\t\treturn idx;\n\t\t\t\t\t} );\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 names.map( 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\tcase 'title':\n\t\t\t\t\t// match by column title\n\t\t\t\t\treturn titles.map( function (title, i) {\n\t\t\t\t\t\treturn title === 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 _fnColumnsFromHeader( this ); // `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\tcells, 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 false;\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 = _pluck(cols, 'bVisible').indexOf(true, column+1);\n\n\t\tfor ( i=0, ien=data.length ; i<ien ; i++ ) {\n\t\t\tif (data[i]) {\n\t\t\t\ttr = data[i].nTr;\n\t\t\t\tcells = data[i].anCells;\n\n\t\t\t\tif ( tr ) {\n\t\t\t\t\t// insertBefore can act like appendChild if 2nd arg is null\n\t\t\t\t\ttr.insertBefore( cells[ column ], cells[ insertBefore ] || null );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\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\t_colGroup(settings);\n\t\n\treturn true;\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 ( row ) {\n\treturn this.iterator( 'column', function (settings, column) {\n\t\treturn __column_header(settings, column, row);\n\t}, 1 );\n} );\n\n_api_registerPlural( 'columns().footer()', 'column().footer()', function ( row ) {\n\treturn this.iterator( 'column', function ( settings, column ) {\n\t\tvar footer = settings.aoFooter;\n\n\t\tif (! footer.length) {\n\t\t\treturn null;\n\t\t}\n\n\t\treturn settings.aoFooter[row !== undefined ? row : 0][column].cell;\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().render()', 'column().render()', function ( type ) {\n\treturn this.iterator( 'column-rows', function ( settings, column, i, j, rows ) {\n\t\treturn __columnData( settings, column, i, j, rows, type );\n\t}, 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().init()', 'column().init()', function () {\n\treturn this.iterator( 'column', function ( settings, column ) {\n\t\treturn settings.aoColumns[column];\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().titles()', 'column().title()', function (title, row) {\n\treturn this.iterator( 'column', function ( settings, column ) {\n\t\t// Argument shifting\n\t\tif (typeof title === 'number') {\n\t\t\trow = title;\n\t\t\ttitle = undefined;\n\t\t}\n\n\t\tvar span = $('span.dt-column-title', this.column(column).header(row));\n\n\t\tif (title !== undefined) {\n\t\t\tspan.html(title);\n\t\t\treturn this;\n\t\t}\n\n\t\treturn span.html();\n\t}, 1 );\n} );\n\n_api_registerPlural( 'columns().types()', 'column().type()', function () {\n\treturn this.iterator( 'column', function ( settings, column ) {\n\t\tvar type = settings.aoColumns[column].sType;\n\n\t\t// If the type was invalidated, then resolve it. This actually does\n\t\t// all columns at the moment. Would only happen once if getting all\n\t\t// column's data types.\n\t\tif (! type) {\n\t\t\t_fnColumnTypes(settings);\n\t\t}\n\n\t\treturn type;\n\t}, 1 );\n} );\n\n_api_registerPlural( 'columns().visible()', 'column().visible()', function ( vis, calc ) {\n\tvar that = this;\n\tvar changed = [];\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\n\t\tif (__setColumnVis( settings, column, vis )) {\n\t\t\tchanged.push(column);\n\t\t}\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\tif (changed.includes(column)) {\n\t\t\t\t\t_fnCallbackFire( settings, null, 'column-visibility', [settings, column, vis, calc] );\n\t\t\t\t}\n\t\t\t} );\n\n\t\t\tif ( changed.length && (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().widths()', 'column().width()', function () {\n\t// Injects a fake row into the table for just a moment so the widths can\n\t// be read, regardless of colspan in the header and rows being present in\n\t// the body\n\tvar columns = this.columns(':visible').count();\n\tvar row = $('<tr>').html('<td>' + Array(columns).join('</td><td>') + '</td>');\n\n\t$(this.table().body()).append(row);\n\n\tvar widths = row.children().map(function () {\n\t\treturn $(this).outerWidth();\n\t});\n\n\trow.remove();\n\t\n\treturn this.iterator( 'column', function ( settings, column ) {\n\t\tvar visIdx = _fnColumnIndexToVisible( settings, column );\n\n\t\treturn visIdx !== null ? widths[visIdx] : 0;\n\t}, 1);\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 && rows.indexOf(s.row) !== -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\tvar args = Array.prototype.slice.call( arguments );\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 ( args.length > 1 ) {\n\t\t// Arguments passed in (list of 1D arrays)\n\t\torder = args;\n\t}\n\t// otherwise a 2D array was passed in\n\n\treturn this.iterator( 'table', function ( settings ) {\n\t\tsettings.aaSorting = Array.isArray(order) ? order.slice() : order;\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\tif ( ! dir ) {\n\t\treturn this.iterator( 'column', function ( settings, idx ) {\n\t\t\tvar sort = _fnSortFlatten( settings );\n\n\t\t\tfor ( var i=0, ien=sort.length ; i<ien ; i++ ) {\n\t\t\t\tif ( sort[i].col === idx ) {\n\t\t\t\t\treturn sort[i].dir;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn null;\n\t\t}, 1 );\n\t}\n\telse {\n\t\treturn this.iterator( 'table', function ( settings, i ) {\n\t\t\tsettings.aaSorting = that[i].map( function (col) {\n\t\t\t\treturn [ col, dir ];\n\t\t\t} );\n\t\t} );\n\t}\n} );\n\n_api_registerPlural('columns().orderable()', 'column().orderable()', function ( directions ) {\n\treturn this.iterator( 'column', function ( settings, idx ) {\n\t\tvar col = settings.aoColumns[idx];\n\n\t\treturn directions ?\n\t\t\tcol.asSorting :\n\t\t\tcol.bSortable;\n\t}, 1 );\n} );\n\n\n_api_register( 'processing()', function ( show ) {\n\treturn this.iterator( 'table', function ( ctx ) {\n\t\t_fnProcessingDisplay( ctx, show );\n\t} );\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.search :\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\tif (typeof regex === 'object') {\n\t\t\t// New style options to pass to the search builder\n\t\t\t_fnFilterComplete( settings, $.extend( settings.oPreviousSearch, regex, {\n\t\t\t\tsearch: input\n\t\t\t} ) );\n\t\t}\n\t\telse {\n\t\t\t// Compat for the old options\n\t\t\t_fnFilterComplete( settings, $.extend( settings.oPreviousSearch, {\n\t\t\t\tsearch: input,\n\t\t\t\tregex:  regex === null ? false : regex,\n\t\t\t\tsmart:  smart === null ? true  : smart,\n\t\t\t\tcaseInsensitive: caseInsen === null ? true : caseInsen\n\t\t\t} ) );\n\t\t}\n\t} );\n} );\n\n_api_register( 'search.fixed()', function ( name, search ) {\n\tvar ret = this.iterator( true, 'table', function ( settings ) {\n\t\tvar fixed = settings.searchFixed;\n\n\t\tif (! name) {\n\t\t\treturn Object.keys(fixed)\n\t\t}\n\t\telse if (search === undefined) {\n\t\t\treturn fixed[name];\n\t\t}\n\t\telse if (search === null) {\n\t\t\tdelete fixed[name];\n\t\t}\n\t\telse {\n\t\t\tfixed[name] = search;\n\t\t}\n\n\t\treturn this;\n\t} );\n\n\treturn name !== undefined && search === undefined\n\t\t? ret[0]\n\t\t: ret;\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 ].search;\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\tif (typeof regex === 'object') {\n\t\t\t\t// New style options to pass to the search builder\n\t\t\t\t$.extend( preSearch[ column ], regex, {\n\t\t\t\t\tsearch: input\n\t\t\t\t} );\n\t\t\t}\n\t\t\telse {\n\t\t\t\t// Old style (with not all options available)\n\t\t\t\t$.extend( preSearch[ column ], {\n\t\t\t\t\tsearch: input,\n\t\t\t\t\tregex:  regex === null ? false : regex,\n\t\t\t\t\tsmart:  smart === null ? true  : smart,\n\t\t\t\t\tcaseInsensitive: caseInsen === null ? true : caseInsen\n\t\t\t\t} );\n\t\t\t}\n\n\t\t\t_fnFilterComplete( settings, settings.oPreviousSearch );\n\t\t} );\n\t}\n);\n\n_api_register([\n\t\t'columns().search.fixed()',\n\t\t'column().search.fixed()'\n\t],\n\tfunction ( name, search ) {\n\t\tvar ret = this.iterator( true, 'column', function ( settings, colIdx ) {\n\t\t\tvar fixed = settings.aoColumns[colIdx].searchFixed;\n\n\t\t\tif (! name) {\n\t\t\t\treturn Object.keys(fixed)\n\t\t\t}\n\t\t\telse if (search === undefined) {\n\t\t\t\treturn fixed[name];\n\t\t\t}\n\t\t\telse if (search === null) {\n\t\t\t\tdelete fixed[name];\n\t\t\t}\n\t\t\telse {\n\t\t\t\tfixed[name] = search;\n\t\t\t}\n\n\t\t\treturn this;\n\t\t} );\n\n\t\treturn name !== undefined && search === undefined\n\t\t\t? ret[0]\n\t\t\t: ret;\n\t}\n);\n/*\n * State API methods\n */\n\n_api_register( 'state()', function ( set, ignoreTime ) {\n\t// getter\n\tif ( ! set ) {\n\t\treturn this.context.length ?\n\t\t\tthis.context[0].oSavedState :\n\t\t\tnull;\n\t}\n\n\tvar setMutate = $.extend( true, {}, set );\n\n\t// setter\n\treturn this.iterator( 'table', function ( settings ) {\n\t\tif ( ignoreTime !== false ) {\n\t\t\tsetMutate.time = +new Date() + 100;\n\t\t}\n\n\t\t_fnImplementState( settings, setMutate, function(){} );\n\t} );\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 * Set the libraries that DataTables uses, or the global objects.\n * Note that the arguments can be either way around (legacy support)\n * and the second is optional. See docs.\n */\nDataTable.use = function (arg1, arg2) {\n\t// Reverse arguments for legacy support\n\tvar module = typeof arg1 === 'string'\n\t\t? arg2\n\t\t: arg1;\n\tvar type = typeof arg2 === 'string'\n\t\t? arg2\n\t\t: arg1;\n\n\t// Getter\n\tif (module === undefined && typeof type === 'string') {\n\t\tswitch (type) {\n\t\t\tcase 'lib':\n\t\t\tcase 'jq':\n\t\t\t\treturn $;\n\n\t\t\tcase 'win':\n\t\t\t\treturn window;\n\n\t\t\tcase 'datetime':\n\t\t\t\treturn DataTable.DateTime;\n\n\t\t\tcase 'luxon':\n\t\t\t\treturn __luxon;\n\n\t\t\tcase 'moment':\n\t\t\t\treturn __moment;\n\n\t\t\tdefault:\n\t\t\t\treturn null;\n\t\t}\n\t}\n\n\t// Setter\n\tif (type === 'lib' || type === 'jq' || (module && module.fn && module.fn.jquery)) {\n\t\t$ = module;\n\t}\n\telse if (type == 'win' || (module && module.document)) {\n\t\twindow = module;\n\t\tdocument = module.document;\n\t}\n\telse if (type === 'datetime' || (module && module.type === 'DateTime')) {\n\t\tDataTable.DateTime = module;\n\t}\n\telse if (type === 'luxon' || (module && module.FixedOffsetZone)) {\n\t\t__luxon = module;\n\t}\n\telse if (type === 'moment' || (module && module.isMoment)) {\n\t\t__moment = 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 *  @param {string} [version2=current DataTables version] As above, but optional.\n *   If not given the current DataTables version will be used.\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 = function( version, version2 )\n{\n\tvar aThis = version2 ?\n\t\tversion2.split('.') :\n\t\tDataTable.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 = 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 = 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 = DataTable.settings\n\t\t.filter( function (o) {\n\t\t\treturn !visible || (visible && $(o.nTable).is(':visible')) \n\t\t\t\t? true\n\t\t\t\t: false;\n\t\t} )\n\t\t.map( function (o) {\n\t\t\treturn o.nTable;\n\t\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] = args[0].split( /\\s/ ).map( 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( 'error()', function (msg) {\n\treturn this.iterator( 'table', function ( settings ) {\n\t\t_fnLog( settings, 0, msg );\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( 'trigger()', function ( name, args, bubbles ) {\n\treturn this.iterator( 'table', function ( settings ) {\n\t\treturn _fnCallbackFire( settings, null, name, args, bubbles );\n\t} ).flatten();\n} );\n\n\n_api_register( 'ready()', function ( fn ) {\n\tvar ctx = this.context;\n\n\t// Get status of first table\n\tif (! fn) {\n\t\treturn ctx.length\n\t\t\t? (ctx[0]._bInitComplete || false)\n\t\t\t: null;\n\t}\n\n\t// Function to run either once the table becomes ready or\n\t// immediately if it is already ready.\n\treturn this.tables().every(function () {\n\t\tif (this.context[0]._bInitComplete) {\n\t\t\tfn.call(this);\n\t\t}\n\t\telse {\n\t\t\tthis.on('init', function () {\n\t\t\t\tfn.call(this);\n\t\t\t});\n\t\t}\n\t} );\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      = settings.aoData.map( function (r) { return r ? r.nTr : null; } );\n\t\tvar orderClasses = classes.order;\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], true );\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.colgroup.remove();\n\n\t\tsettings.aaSorting = [];\n\t\tsettings.aaSortingFixed = [];\n\t\t_fnSortingClasses( settings );\n\n\t\t$('th, td', thead)\n\t\t\t.removeClass(\n\t\t\t\torderClasses.canAsc + ' ' +\n\t\t\t\torderClasses.canDesc + ' ' +\n\t\t\t\torderClasses.isAsc + ' ' +\n\t\t\t\torderClasses.isDesc\n\t\t\t)\n\t\t\t.css('width', '');\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\t\tvar insertBefore = settings.nTableWrapper.nextSibling;\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, insertBefore );\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.table );\n\t\t}\n\n\t\t/* Remove the settings object from the settings array */\n\t\tvar idx = DataTable.settings.indexOf(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\t\tvar inst;\n\t\tvar counter = 0;\n\n\t\treturn this.iterator( 'every', function ( settings, selectedIdx, tableIdx ) {\n\t\t\tinst = api[ type ](selectedIdx, opts);\n\n\t\t\tif (type === 'cell') {\n\t\t\t\tfn.call(inst, inst[0][0].row, inst[0][0].column, tableIdx, counter);\n\t\t\t}\n\t\t\telse {\n\t\t\t\tfn.call(inst, selectedIdx, tableIdx, counter);\n\t\t\t}\n\n\t\t\tcounter++;\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 ( $.isPlainObject( resolved ) ) {\n\t\tresolved = plural !== undefined && 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/**\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 = \"2.1.5\";\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 */\n\t\"caseInsensitive\": true,\n\n\t/**\n\t * Applied search term\n\t */\n\t\"search\": \"\",\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 */\n\t\"regex\": false,\n\n\t/**\n\t * Flag to indicate if DataTables is to use its smart filtering or not.\n\t */\n\t\"smart\": 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 */\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 */\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 */\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 */\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 */\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 */\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 */\n\t\"_sFilterRow\": null,\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 */\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 */\n\t\"idx\": -1,\n\n\t/**\n\t * Cached display value\n\t */\n\tdisplayData: null\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.\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 */\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 */\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 */\n\t\"bSearchable\": null,\n\n\t/**\n\t * Flag to indicate if the column is sortable or not.\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 */\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 */\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 */\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 */\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 */\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 */\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 */\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 */\n\t\"mRender\": null,\n\n\t/**\n\t * The class to apply to all TD elements in the table's TBODY for the column\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 */\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 */\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 */\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 */\n\t\"sSortDataType\": 'std',\n\n\t/**\n\t * Class to be applied to the header element when sorting on this column\n\t */\n\t\"sSortingClass\": null,\n\n\t/**\n\t * Title of the column - what is seen in the TH element (nTh).\n\t */\n\t\"sTitle\": null,\n\n\t/**\n\t * Column sorting and filtering type\n\t */\n\t\"sType\": null,\n\n\t/**\n\t * Width of the column\n\t */\n\t\"sWidth\": null,\n\n\t/**\n\t * Width of the column when it was first \"encountered\"\n\t */\n\t\"sWidthOrig\": null,\n\n\t/** Cached string which is the longest in the column */\n\tmaxLenString: null,\n\n\t/**\n\t * Store for named searches\n\t */\n\tsearchFixed: 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 */\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 */\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 */\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.\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\"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 */\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 */\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 */\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 */\n\t\"aoSearchCols\": [],\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 */\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 */\n\t\"bDeferRender\": true,\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 */\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 */\n\t\"bFilter\": true,\n\n\t/**\n\t * Used only for compatiblity with DT1\n\t * @deprecated\n\t */\n\t\"bInfo\": true,\n\n\t/**\n\t * Used only for compatiblity with DT1\n\t * @deprecated\n\t */\n\t\"bLengthChange\": true,\n\n\t/**\n\t * Enable or disable pagination.\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 */\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 */\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 */\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 */\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 */\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 */\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 */\n\t\"bSortCellsTop\": null,\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 */\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\"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 */\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 */\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 */\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 */\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 */\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 */\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 */\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 */\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 */\n\t\"fnRowCallback\": 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 */\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 */\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 */\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 */\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\t\t// noop\n\t\t}\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 */\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 */\n\t\"iStateDuration\": 7200,\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 */\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 */\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 */\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 */\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 */\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 */\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 sorted\n\t\t\t */\n\t\t\t\"orderable\": \": Activate to sort\",\n\n\t\t\t/**\n\t\t\t * ARIA label that is added to the table headers when the column is currently being sorted\n\t\t\t */\n\t\t\t\"orderableReverse\": \": Activate to invert sorting\",\n\n\t\t\t/**\n\t\t\t * ARIA label that is added to the table headers when the column is currently being \n\t\t\t * sorted and next step is to remove sorting\n\t\t\t */\n\t\t\t\"orderableRemove\": \": Activate to remove sorting\",\n\n\t\t\tpaginate: {\n\t\t\t\tfirst: 'First',\n\t\t\t\tlast: 'Last',\n\t\t\t\tnext: 'Next',\n\t\t\t\tprevious: 'Previous',\n\t\t\t\tnumber: ''\n\t\t\t}\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 */\n\t\t\"oPaginate\": {\n\t\t\t/**\n\t\t\t * Label and character for first page button («)\n\t\t\t */\n\t\t\t\"sFirst\": \"\\u00AB\",\n\n\t\t\t/**\n\t\t\t * Last page button (»)\n\t\t\t */\n\t\t\t\"sLast\": \"\\u00BB\",\n\n\t\t\t/**\n\t\t\t * Next page button (›)\n\t\t\t */\n\t\t\t\"sNext\": \"\\u203A\",\n\n\t\t\t/**\n\t\t\t * Previous page button (‹)\n\t\t\t */\n\t\t\t\"sPrevious\": \"\\u2039\",\n\t\t},\n\n\t\t/**\n\t\t * Plural object for the data type the table is showing\n\t\t */\n\t\tentries: {\n\t\t\t_: \"entries\",\n\t\t\t1: \"entry\"\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 */\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\"sInfo\": \"Showing _START_ to _END_ of _TOTAL_ _ENTRIES-TOTAL_\",\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 */\n\t\t\"sInfoEmpty\": \"Showing 0 to 0 of 0 _ENTRIES-TOTAL_\",\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 */\n\t\t\"sInfoFiltered\": \"(filtered from _MAX_ total _ENTRIES-MAX_)\",\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 */\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 */\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 */\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 */\n\t\t\"sLengthMenu\": \"_MENU_ _ENTRIES_ per page\",\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 */\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 */\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 */\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 */\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 */\n\t\t\"sZeroRecords\": \"No matching records found\"\n\t},\n\n\n\t/** The initial data order is reversed when `desc` ordering */\n\torderDescReverse: true,\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 */\n\t\"oSearch\": $.extend( {}, DataTable.models.oSearch ),\n\n\n\t/**\n\t * Table and control layout. This replaces the legacy `dom` option.\n\t */\n\tlayout: {\n\t\ttopStart: 'pageLength',\n\t\ttopEnd: 'search',\n\t\tbottomStart: 'info',\n\t\tbottomEnd: 'paging'\n\t},\n\n\n\t/**\n\t * Legacy DOM layout option\n\t */\n\t\"sDom\": null,\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 */\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\"sPaginationType\": \"\",\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 */\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 */\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 */\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 */\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 */\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 */\n\t\"rowId\": \"DT_RowId\",\n\n\n\t/**\n\t * Caption value\n\t */\n\t\"caption\": null,\n\n\n\t/**\n\t * For server-side processing - use the data from the DOM for the first draw\n\t */\n\tiDeferLoading: null\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 */\n\t\"aDataSort\": null,\n\t\"iDataSort\": -1,\n\n\tariaTitle: '',\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 */\n\t\"asSorting\": [ 'asc', 'desc', '' ],\n\n\n\t/**\n\t * Enable or disable filtering on the data in this column.\n\t */\n\t\"bSearchable\": true,\n\n\n\t/**\n\t * Enable or disable ordering on this column.\n\t */\n\t\"bSortable\": true,\n\n\n\t/**\n\t * Enable or disable the display of this column.\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 */\n\t\"fnCreatedCell\": null,\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\"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\"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 */\n\t\"sCellType\": \"td\",\n\n\n\t/**\n\t * Class to give to each cell in this column.\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 */\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 */\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 */\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 */\n\t\"sSortDataType\": \"std\",\n\n\n\t/**\n\t * The title of this column.\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 */\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 */\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 */\nDataTable.models.oSettings = {\n\t/**\n\t * Primary features of DataTables and their enablement state.\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 */\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 */\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 */\n\t\t\"bFilter\": null,\n\n\t\t/**\n\t\t * Used only for compatiblity with DT1\n\t\t * @deprecated\n\t\t */\n\t\t\"bInfo\": true,\n\n\t\t/**\n\t\t * Used only for compatiblity with DT1\n\t\t * @deprecated\n\t\t */\n\t\t\"bLengthChange\": true,\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 */\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 */\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 */\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 */\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 */\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 */\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 */\n\t\t\"bStateSave\": null\n\t},\n\n\n\t/**\n\t * Scrolling settings for a table.\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 */\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 */\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 */\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 *  @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 */\n\t\t\"sY\": null\n\t},\n\n\t/**\n\t * Language information for the table.\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 */\n\t\t\"fnInfoCallback\": null\n\t},\n\n\t/**\n\t * Browser support parameters\n\t */\n\t\"oBrowser\": {\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 */\n\t\t\"bScrollbarLeft\": false,\n\n\t\t/**\n\t\t * Browser scrollbar width\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 */\n\t\"aanFeatures\": [],\n\n\t/**\n\t * Store data information - see {@link DataTable.models.oRow} for detailed\n\t * information.\n\t */\n\t\"aoData\": [],\n\n\t/**\n\t * Array of indexes which are in the current display (after filtering etc)\n\t */\n\t\"aiDisplay\": [],\n\n\t/**\n\t * Array of indexes for display - no filtering\n\t */\n\t\"aiDisplayMaster\": [],\n\n\t/**\n\t * Map of row ids to data indexes\n\t */\n\t\"aIds\": {},\n\n\t/**\n\t * Store information about each column that is in use\n\t */\n\t\"aoColumns\": [],\n\n\t/**\n\t * Store information about the table's header\n\t */\n\t\"aoHeader\": [],\n\n\t/**\n\t * Store information about the table's footer\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 */\n\t\"oPreviousSearch\": {},\n\n\t/**\n\t * Store for named searches\n\t */\n\tsearchFixed: {},\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 */\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 */\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 */\n\t\"aaSortingFixed\": [],\n\n\t/**\n\t * If restoring a table - we should restore its width\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 */\n\t\"aoRowCallback\": [],\n\n\t/**\n\t * Callback functions for the header on each draw.\n\t */\n\t\"aoHeaderCallback\": [],\n\n\t/**\n\t * Callback function for the footer on each draw.\n\t */\n\t\"aoFooterCallback\": [],\n\n\t/**\n\t * Array of callback functions for draw callback functions\n\t */\n\t\"aoDrawCallback\": [],\n\n\t/**\n\t * Array of callback functions for row created function\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 */\n\t\"aoPreDrawCallback\": [],\n\n\t/**\n\t * Callback functions for when the table has been initialised.\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 */\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 */\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 */\n\t\"aoStateLoaded\": [],\n\n\t/**\n\t * Cache the table ID for quick access\n\t */\n\t\"sTableId\": \"\",\n\n\t/**\n\t * The TABLE node for the main table\n\t */\n\t\"nTable\": null,\n\n\t/**\n\t * Permanent ref to the thead element\n\t */\n\t\"nTHead\": null,\n\n\t/**\n\t * Permanent ref to the tfoot element - if it exists\n\t */\n\t\"nTFoot\": null,\n\n\t/**\n\t * Permanent ref to the tbody element\n\t */\n\t\"nTBody\": null,\n\n\t/**\n\t * Cache the wrapper node (contains all DataTables controlled elements)\n\t */\n\t\"nTableWrapper\": null,\n\n\t/**\n\t * Indicate if all required information has been read in\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 */\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 */\n\t\"sDom\": null,\n\n\t/**\n\t * Search delay (in mS)\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 */\n\t\"sPaginationType\": \"two_button\",\n\n\t/**\n\t * Number of paging controls on the page. Only used for backwards compatibility\n\t */\n\tpagingControls: 0,\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 */\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 */\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 */\n\t\"aoStateLoad\": [],\n\n\t/**\n\t * State that was saved. Useful for back reference\n\t */\n\t\"oSavedState\": null,\n\n\t/**\n\t * State that was loaded. Useful for back reference\n\t */\n\t\"oLoadedState\": null,\n\n\t/**\n\t * Note if draw should be blocked while getting data\n\t */\n\t\"bAjaxDataGet\": true,\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 */\n\t\"jqXHR\": null,\n\n\t/**\n\t * JSON returned from the server in the last Ajax request\n\t */\n\t\"json\": undefined,\n\n\t/**\n\t * Data submitted as part of the last Ajax request\n\t */\n\t\"oAjaxData\": undefined,\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 */\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 */\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 */\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 */\n\t\"iDraw\": 0,\n\n\t/**\n\t * Indicate if a redraw is being done - useful for Ajax\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 */\n\t\"iDrawError\": -1,\n\n\t/**\n\t * Paging display length\n\t */\n\t\"_iDisplayLength\": 10,\n\n\t/**\n\t * Paging start point - aiDisplay index\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 */\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 */\n\t\"_iRecordsDisplay\": 0,\n\n\t/**\n\t * The classes to use for the table\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 *  @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 *  @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 */\n\t\"bSortCellsTop\": null,\n\n\t/**\n\t * Initialisation object that is used for the table\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 */\n\t\"aoDestroyCallback\": [],\n\n\n\t/**\n\t * Get the number of records in the current record set, before filtering\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 */\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 */\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 */\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 */\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 */\n\t\"aLastSort\": [],\n\n\t/**\n\t * Stored plug-in instances\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 */\n\t\"rowIdFn\": null,\n\n\t/**\n\t * Data location where to store a row's id\n\t */\n\t\"rowId\": null,\n\n\tcaption: '',\n\n\tcaptionNode: null,\n\n\tcolgroup: null,\n\n\t/** Delay loading of data */\n\tdeferLoading: 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\nvar extPagination = DataTable.ext.pager;\n\n// Paging buttons configuration\n$.extend( extPagination, {\n\tsimple: function () {\n\t\treturn [ 'previous', 'next' ];\n\t},\n\n\tfull: function () {\n\t\treturn [ 'first', 'previous', 'next', 'last' ];\n\t},\n\n\tnumbers: function () {\n\t\treturn [ 'numbers' ];\n\t},\n\n\tsimple_numbers: function () {\n\t\treturn [ 'previous', 'numbers', 'next' ];\n\t},\n\n\tfull_numbers: function () {\n\t\treturn [ 'first', 'previous', 'numbers', 'next', 'last' ];\n\t},\n\n\tfirst_last: function () {\n\t\treturn ['first', 'last'];\n\t},\n\n\tfirst_last_numbers: function () {\n\t\treturn ['first', 'numbers', 'last'];\n\t},\n\n\t// For testing and plug-ins to use\n\t_numbers: _pagingNumbers,\n\n\t// Number of number buttons - legacy, use `numbers` option for paging feature\n\tnumbers_length: 7\n} );\n\n\n$.extend( true, DataTable.ext.renderer, {\n\tpagingButton: {\n\t\t_: function (settings, buttonType, content, active, disabled) {\n\t\t\tvar classes = settings.oClasses.paging;\n\t\t\tvar btnClasses = [classes.button];\n\t\t\tvar btn;\n\n\t\t\tif (active) {\n\t\t\t\tbtnClasses.push(classes.active);\n\t\t\t}\n\n\t\t\tif (disabled) {\n\t\t\t\tbtnClasses.push(classes.disabled)\n\t\t\t}\n\n\t\t\tif (buttonType === 'ellipsis') {\n\t\t\t\tbtn = $('<span class=\"ellipsis\"></span>').html(content)[0];\n\t\t\t}\n\t\t\telse {\n\t\t\t\tbtn = $('<button>', {\n\t\t\t\t\tclass: btnClasses.join(' '),\n\t\t\t\t\trole: 'link',\n\t\t\t\t\ttype: 'button'\n\t\t\t\t}).html(content);\n\t\t\t}\n\n\t\t\treturn {\n\t\t\t\tdisplay: btn,\n\t\t\t\tclicker: btn\n\t\t\t}\n\t\t}\n\t},\n\n\tpagingContainer: {\n\t\t_: function (settings, buttons) {\n\t\t\t// No wrapping element - just append directly to the host\n\t\t\treturn buttons;\n\t\t}\n\t}\n} );\n\n// Common function to remove new lines, strip HTML and diacritic control\nvar _filterString = function (stripHtml, normalize) {\n\treturn function (str) {\n\t\tif (_empty(str) || typeof str !== 'string') {\n\t\t\treturn str;\n\t\t}\n\n\t\tstr = str.replace( _re_new_lines, \" \" );\n\n\t\tif (stripHtml) {\n\t\t\tstr = _stripHtml(str);\n\t\t}\n\n\t\tif (normalize) {\n\t\t\tstr = _normalize(str, false);\n\t\t}\n\n\t\treturn str;\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\n/**\n * Common logic for moment, luxon or a date action.\n *\n * Happens after __mldObj, so don't need to call `resolveWindowsLibs` again\n */\nfunction __mld( dtLib, momentFn, luxonFn, dateFn, arg1 ) {\n\tif (__moment) {\n\t\treturn dtLib[momentFn]( arg1 );\n\t}\n\telse if (__luxon) {\n\t\treturn dtLib[luxonFn]( arg1 );\n\t}\n\t\n\treturn dateFn ? dtLib[dateFn]( arg1 ) : dtLib;\n}\n\n\nvar __mlWarning = false;\nvar __luxon; // Can be assigned in DateTeble.use()\nvar __moment; // Can be assigned in DateTeble.use()\n\n/**\n * \n */\nfunction resolveWindowLibs() {\n\tif (window.luxon && ! __luxon) {\n\t\t__luxon = window.luxon;\n\t}\n\t\n\tif (window.moment && ! __moment) {\n\t\t__moment = window.moment;\n\t}\n}\n\nfunction __mldObj (d, format, locale) {\n\tvar dt;\n\n\tresolveWindowLibs();\n\n\tif (__moment) {\n\t\tdt = __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 (__luxon) {\n\t\tdt = format && typeof d === 'string'\n\t\t\t? __luxon.DateTime.fromFormat( d, format )\n\t\t\t: __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 ? '-' + 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\tDataTable.type(typeName, {\n\t\t\t\tdetect: function (d) {\n\t\t\t\t\t// The renderer will give the value to type detect as the type!\n\t\t\t\t\treturn d === typeName ? typeName : false;\n\t\t\t\t},\n\t\t\t\torder: {\n\t\t\t\t\tpre: function (d) {\n\t\t\t\t\t\t// The renderer gives us Moment, Luxon or Date obects for the sorting, all of which have a\n\t\t\t\t\t\t// `valueOf` which gives milliseconds epoch\n\t\t\t\t\t\treturn d.valueOf();\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t\tclassName: 'dt-right'\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_escapeHtml( 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-' + format;\n\n\tif (! locale) {\n\t\tlocale = 'en';\n\t}\n\n\tif (! DataTable.ext.type.order[typeName]) {\n\t\tDataTable.type(typeName, {\n\t\t\tdetect: function (d) {\n\t\t\t\tvar dt = __mldObj(d, format, locale);\n\t\t\t\treturn d === '' || dt ? typeName : false;\n\t\t\t},\n\t\t\torder: {\n\t\t\t\tpre: function (d) {\n\t\t\t\t\treturn __mldObj(d, format, locale) || 0;\n\t\t\t\t}\n\t\t\t},\n\t\t\tclassName: 'dt-right'\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 * * `moment` - Uses the MomentJS library to convert from a given format into another.\n * This renderer has three overloads:\n *   * 1 parameter:\n *     * `string` - Format to convert to (assumes input is ISO8601 and locale is `en`)\n *   * 2 parameters:\n *     * `string` - Format to convert from\n *     * `string` - Format to convert to. Assumes `en` locale\n *   * 3 parameters:\n *     * `string` - Format to convert from\n *     * `string` - Format to convert to\n *     * `string` - Locale\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\t\t\t\tvar abs = Math.abs(flo);\n\n\t\t\t\t// Scientific notation for large and small numbers\n\t\t\t\tif (abs >= 100000000000 || (abs < 0.0001 && abs !== 0) ) {\n\t\t\t\t\tvar exp = flo.toExponential(precision).split(/e\\+?/);\n\t\t\t\t\treturn exp[0] + ' x 10<sup>' + exp[1] + '</sup>';\n\t\t\t\t}\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 _escapeHtml( 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: _escapeHtml,\n\t\t\tfilter: _escapeHtml\n\t\t};\n\t}\n};\n\n\nvar _extTypes = DataTable.ext.type;\n\n// Get / set type\nDataTable.type = function (name, prop, val) {\n\tif (! prop) {\n\t\treturn {\n\t\t\tclassName: _extTypes.className[name],\n\t\t\tdetect: _extTypes.detect.find(function (fn) {\n\t\t\t\treturn fn.name === name;\n\t\t\t}),\n\t\t\torder: {\n\t\t\t\tpre: _extTypes.order[name + '-pre'],\n\t\t\t\tasc: _extTypes.order[name + '-asc'],\n\t\t\t\tdesc: _extTypes.order[name + '-desc']\n\t\t\t},\n\t\t\trender: _extTypes.render[name],\n\t\t\tsearch: _extTypes.search[name]\n\t\t};\n\t}\n\n\tvar setProp = function(prop, propVal) {\n\t\t_extTypes[prop][name] = propVal;\n\t};\n\tvar setDetect = function (detect) {\n\t\t// `detect` can be a function or an object - we set a name\n\t\t// property for either - that is used for the detection\n\t\tObject.defineProperty(detect, \"name\", {value: name});\n\n\t\tvar idx = _extTypes.detect.findIndex(function (item) {\n\t\t\treturn item.name === name;\n\t\t});\n\n\t\tif (idx === -1) {\n\t\t\t_extTypes.detect.unshift(detect);\n\t\t}\n\t\telse {\n\t\t\t_extTypes.detect.splice(idx, 1, detect);\n\t\t}\n\t};\n\tvar setOrder = function (obj) {\n\t\t_extTypes.order[name + '-pre'] = obj.pre; // can be undefined\n\t\t_extTypes.order[name + '-asc'] = obj.asc; // can be undefined\n\t\t_extTypes.order[name + '-desc'] = obj.desc; // can be undefined\n\t};\n\n\t// prop is optional\n\tif (val === undefined) {\n\t\tval = prop;\n\t\tprop = null;\n\t}\n\n\tif (prop === 'className') {\n\t\tsetProp('className', val);\n\t}\n\telse if (prop === 'detect') {\n\t\tsetDetect(val);\n\t}\n\telse if (prop === 'order') {\n\t\tsetOrder(val);\n\t}\n\telse if (prop === 'render') {\n\t\tsetProp('render', val);\n\t}\n\telse if (prop === 'search') {\n\t\tsetProp('search', val);\n\t}\n\telse if (! prop) {\n\t\tif (val.className) {\n\t\t\tsetProp('className', val.className);\n\t\t}\n\n\t\tif (val.detect !== undefined) {\n\t\t\tsetDetect(val.detect);\n\t\t}\n\n\t\tif (val.order) {\n\t\t\tsetOrder(val.order);\n\t\t}\n\n\t\tif (val.render !== undefined) {\n\t\t\tsetProp('render', val.render);\n\t\t}\n\n\t\tif (val.search !== undefined) {\n\t\t\tsetProp('search', val.search);\n\t\t}\n\t}\n}\n\n// Get a list of types\nDataTable.types = function () {\n\treturn _extTypes.detect.map(function (fn) {\n\t\treturn fn.name;\n\t});\n};\n\nvar __diacriticSort = function (a, b) {\n\ta = a.toString().toLowerCase();\n\tb = b.toString().toLowerCase();\n\n\t// Checked for `navigator.languages` support in `oneOf` so this code can't execute in old\n\t// Safari and thus can disable this check\n\t// eslint-disable-next-line compat/compat\n\treturn a.localeCompare(b, navigator.languages[0] || navigator.language, {\n\t\tnumeric: true,\n\t\tignorePunctuation: true,\n\t});\n}\n\n//\n// Built in data types\n//\n\nDataTable.type('string', {\n\tdetect: function () {\n\t\treturn 'string';\n\t},\n\torder: {\n\t\tpre: function ( a ) {\n\t\t\t// This is a little complex, but faster than always calling toString,\n\t\t\t// http://jsperf.com/tostring-v-check\n\t\t\treturn _empty(a) && typeof a !== 'boolean' ?\n\t\t\t\t'' :\n\t\t\t\ttypeof a === 'string' ?\n\t\t\t\t\ta.toLowerCase() :\n\t\t\t\t\t! a.toString ?\n\t\t\t\t\t\t'' :\n\t\t\t\t\t\ta.toString();\n\t\t}\n\t},\n\tsearch: _filterString(false, true)\n});\n\nDataTable.type('string-utf8', {\n\tdetect: {\n\t\tallOf: function ( d ) {\n\t\t\treturn true;\n\t\t},\n\t\toneOf: function ( d ) {\n\t\t\t// At least one data point must contain a non-ASCII character\n\t\t\t// This line will also check if navigator.languages is supported or not. If not (Safari 10.0-)\n\t\t\t// this data type won't be supported.\n\t\t\t// eslint-disable-next-line compat/compat\n\t\t\treturn ! _empty( d ) && navigator.languages && typeof d === 'string' && d.match(/[^\\x00-\\x7F]/);\n\t\t}\n\t},\n\torder: {\n\t\tasc: __diacriticSort,\n\t\tdesc: function (a, b) {\n\t\t\treturn __diacriticSort(a, b) * -1;\n\t\t}\n\t},\n\tsearch: _filterString(false, true)\n});\n\n\nDataTable.type('html', {\n\tdetect: {\n\t\tallOf: function ( d ) {\n\t\t\treturn _empty( d ) || (typeof d === 'string' && d.indexOf('<') !== -1);\n\t\t},\n\t\toneOf: function ( d ) {\n\t\t\t// At least one data point must contain a `<`\n\t\t\treturn ! _empty( d ) && typeof d === 'string' && d.indexOf('<') !== -1;\n\t\t}\n\t},\n\torder: {\n\t\tpre: function ( a ) {\n\t\t\treturn _empty(a) ?\n\t\t\t\t'' :\n\t\t\t\ta.replace ?\n\t\t\t\t\t_stripHtml(a).trim().toLowerCase() :\n\t\t\t\t\ta+'';\n\t\t}\n\t},\n\tsearch: _filterString(true, true)\n});\n\n\nDataTable.type('date', {\n\tclassName: 'dt-type-date',\n\tdetect: {\n\t\tallOf: function ( d ) {\n\t\t\t// V8 tries _very_ hard to make a string passed into `Date.parse()`\n\t\t\t// valid, so we need to use a regex to restrict date formats. Use a\n\t\t\t// plug-in for anything other than ISO8601 style strings\n\t\t\tif ( d && !(d instanceof Date) && ! _re_date.test(d) ) {\n\t\t\t\treturn null;\n\t\t\t}\n\t\t\tvar parsed = Date.parse(d);\n\t\t\treturn (parsed !== null && !isNaN(parsed)) || _empty(d);\n\t\t},\n\t\toneOf: function ( d ) {\n\t\t\t// At least one entry must be a date or a string with a date\n\t\t\treturn (d instanceof Date) || (typeof d === 'string' && _re_date.test(d));\n\t\t}\n\t},\n\torder: {\n\t\tpre: function ( d ) {\n\t\t\tvar ts = Date.parse( d );\n\t\t\treturn isNaN(ts) ? -Infinity : ts;\n\t\t}\n\t}\n});\n\n\nDataTable.type('html-num-fmt', {\n\tclassName: 'dt-type-numeric',\n\tdetect: {\n\t\tallOf: function ( d, settings ) {\n\t\t\tvar decimal = settings.oLanguage.sDecimal;\n\t\t\treturn _htmlNumeric( d, decimal, true, false );\n\t\t},\n\t\toneOf: function (d, settings) {\n\t\t\t// At least one data point must contain a numeric value\n\t\t\tvar decimal = settings.oLanguage.sDecimal;\n\t\t\treturn _htmlNumeric( d, decimal, true, false );\n\t\t}\n\t},\n\torder: {\n\t\tpre: function ( d, s ) {\n\t\t\tvar dp = s.oLanguage.sDecimal;\n\t\t\treturn __numericReplace( d, dp, _re_html, _re_formatted_numeric );\n\t\t}\n\t},\n\tsearch: _filterString(true, true)\n});\n\n\nDataTable.type('html-num', {\n\tclassName: 'dt-type-numeric',\n\tdetect: {\n\t\tallOf: function ( d, settings ) {\n\t\t\tvar decimal = settings.oLanguage.sDecimal;\n\t\t\treturn _htmlNumeric( d, decimal, false, true );\n\t\t},\n\t\toneOf: function (d, settings) {\n\t\t\t// At least one data point must contain a numeric value\n\t\t\tvar decimal = settings.oLanguage.sDecimal;\n\t\t\treturn _htmlNumeric( d, decimal, false, false );\n\t\t}\n\t},\n\torder: {\n\t\tpre: function ( d, s ) {\n\t\t\tvar dp = s.oLanguage.sDecimal;\n\t\t\treturn __numericReplace( d, dp, _re_html );\n\t\t}\n\t},\n\tsearch: _filterString(true, true)\n});\n\n\nDataTable.type('num-fmt', {\n\tclassName: 'dt-type-numeric',\n\tdetect: {\n\t\tallOf: function ( d, settings ) {\n\t\t\tvar decimal = settings.oLanguage.sDecimal;\n\t\t\treturn _isNumber( d, decimal, true, true );\n\t\t},\n\t\toneOf: function (d, settings) {\n\t\t\t// At least one data point must contain a numeric value\n\t\t\tvar decimal = settings.oLanguage.sDecimal;\n\t\t\treturn _isNumber( d, decimal, true, false );\n\t\t}\n\t},\n\torder: {\n\t\tpre: function ( d, s ) {\n\t\t\tvar dp = s.oLanguage.sDecimal;\n\t\t\treturn __numericReplace( d, dp, _re_formatted_numeric );\n\t\t}\n\t}\n});\n\n\nDataTable.type('num', {\n\tclassName: 'dt-type-numeric',\n\tdetect: {\n\t\tallOf: function ( d, settings ) {\n\t\t\tvar decimal = settings.oLanguage.sDecimal;\n\t\t\treturn _isNumber( d, decimal, false, true );\n\t\t},\n\t\toneOf: function (d, settings) {\n\t\t\t// At least one data point must contain a numeric value\n\t\t\tvar decimal = settings.oLanguage.sDecimal;\n\t\t\treturn _isNumber( d, decimal, false, false );\n\t\t}\n\t},\n\torder: {\n\t\tpre: function (d, s) {\n\t\t\tvar dp = s.oLanguage.sDecimal;\n\t\t\treturn __numericReplace( d, dp );\n\t\t}\n\t}\n});\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$.extend( true, DataTable.ext.renderer, {\n\tfooter: {\n\t\t_: function ( settings, cell, classes ) {\n\t\t\tcell.addClass(classes.tfoot.cell);\n\t\t}\n\t},\n\n\theader: {\n\t\t_: function ( settings, cell, classes ) {\n\t\t\tcell.addClass(classes.thead.cell);\n\n\t\t\tif (! settings.oFeatures.bSort) {\n\t\t\t\tcell.addClass(classes.order.none);\n\t\t\t}\n\n\t\t\tvar legacyTop = settings.bSortCellsTop;\n\t\t\tvar headerRows = cell.closest('thead').find('tr');\n\t\t\tvar rowIdx = cell.parent().index();\n\n\t\t\t// Conditions to not apply the ordering icons\n\t\t\tif (\n\t\t\t\t// Cells and rows which have the attribute to disable the icons\n\t\t\t\tcell.attr('data-dt-order') === 'disable' ||\n\t\t\t\tcell.parent().attr('data-dt-order') === 'disable' ||\n\n\t\t\t\t// Legacy support for `orderCellsTop`. If it is set, then cells\n\t\t\t\t// which are not in the top or bottom row of the header (depending\n\t\t\t\t// on the value) do not get the sorting classes applied to them\n\t\t\t\t(legacyTop === true && rowIdx !== 0) ||\n\t\t\t\t(legacyTop === false && rowIdx !== headerRows.length - 1)\n\t\t\t) {\n\t\t\t\treturn;\n\t\t\t}\n\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 column-visibility.dt.DT', function ( e, ctx ) {\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 sorting = ctx.sortDetails;\n\n\t\t\t\tif (! sorting) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tvar i;\n\t\t\t\tvar orderClasses = classes.order;\n\t\t\t\tvar columns = ctx.api.columns( cell );\n\t\t\t\tvar col = settings.aoColumns[columns.flatten()[0]];\n\t\t\t\tvar orderable = columns.orderable().includes(true);\n\t\t\t\tvar ariaType = '';\n\t\t\t\tvar indexes = columns.indexes();\n\t\t\t\tvar sortDirs = columns.orderable(true).flatten();\n\t\t\t\tvar orderedColumns = _pluck(sorting, 'col');\n\n\t\t\t\tcell\n\t\t\t\t\t.removeClass(\n\t\t\t\t\t\torderClasses.isAsc +' '+\n\t\t\t\t\t\torderClasses.isDesc\n\t\t\t\t\t)\n\t\t\t\t\t.toggleClass( orderClasses.none, ! orderable )\n\t\t\t\t\t.toggleClass( orderClasses.canAsc, orderable && sortDirs.includes('asc') )\n\t\t\t\t\t.toggleClass( orderClasses.canDesc, orderable && sortDirs.includes('desc') );\n\n\t\t\t\t// Determine if all of the columns that this cell covers are included in the\n\t\t\t\t// current ordering\n\t\t\t\tvar isOrdering = true;\n\t\t\t\t\n\t\t\t\tfor (i=0; i<indexes.length; i++) {\n\t\t\t\t\tif (! orderedColumns.includes(indexes[i])) {\n\t\t\t\t\t\tisOrdering = false;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tif ( isOrdering ) {\n\t\t\t\t\t// Get the ordering direction for the columns under this cell\n\t\t\t\t\t// Note that it is possible for a cell to be asc and desc sorting\n\t\t\t\t\t// (column spanning cells)\n\t\t\t\t\tvar orderDirs = columns.order();\n\n\t\t\t\t\tcell.addClass(\n\t\t\t\t\t\torderDirs.includes('asc') ? orderClasses.isAsc : '' +\n\t\t\t\t\t\torderDirs.includes('desc') ? orderClasses.isDesc : ''\n\t\t\t\t\t);\n\t\t\t\t}\n\n\t\t\t\t// Find the first visible column that has ordering applied to it - it get's\n\t\t\t\t// the aria information, as the ARIA spec says that only one column should\n\t\t\t\t// be marked with aria-sort\n\t\t\t\tvar firstVis = -1; // column index\n\n\t\t\t\tfor (i=0; i<orderedColumns.length; i++) {\n\t\t\t\t\tif (settings.aoColumns[orderedColumns[i]].bVisible) {\n\t\t\t\t\t\tfirstVis = orderedColumns[i];\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tif (indexes[0] == firstVis) {\n\t\t\t\t\tvar firstSort = sorting[0];\n\t\t\t\t\tvar sortOrder = col.asSorting;\n\n\t\t\t\t\tcell.attr('aria-sort', firstSort.dir === 'asc' ? 'ascending' : 'descending');\n\n\t\t\t\t\t// Determine if the next click will remove sorting or change the sort\n\t\t\t\t\tariaType = ! sortOrder[firstSort.index + 1] ? 'Remove' : 'Reverse';\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tcell.removeAttr('aria-sort');\n\t\t\t\t}\n\n\t\t\t\tcell.attr('aria-label', orderable\n\t\t\t\t\t? col.ariaTitle + ctx.api.i18n('oAria.orderable' + ariaType)\n\t\t\t\t\t: col.ariaTitle\n\t\t\t\t);\n\n\t\t\t\t// Make the headers tab-able for keyboard navigation\n\t\t\t\tif (orderable) {\n\t\t\t\t\tcell.find('.dt-column-title').attr('role', 'button');\n\t\t\t\t\tcell.attr('tabindex', 0)\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\t},\n\n\tlayout: {\n\t\t_: function ( settings, container, items ) {\n\t\t\tvar classes = settings.oClasses.layout;\n\t\t\tvar row = $('<div/>')\n\t\t\t\t.attr('id', items.id || null)\n\t\t\t\t.addClass(items.className || classes.row)\n\t\t\t\t.appendTo( container );\n\n\t\t\t$.each( items, function (key, val) {\n\t\t\t\tif (key === 'id' || key === 'className') {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tvar klass = '';\n\n\t\t\t\tif (val.table) {\n\t\t\t\t\trow.addClass(classes.tableRow);\n\t\t\t\t\tklass += classes.tableCell + ' ';\n\t\t\t\t}\n\n\t\t\t\tif (key === 'start') {\n\t\t\t\t\tklass += classes.start;\n\t\t\t\t}\n\t\t\t\telse if (key === 'end') {\n\t\t\t\t\tklass += classes.end;\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tklass += classes.full;\n\t\t\t\t}\n\n\t\t\t\t$('<div/>')\n\t\t\t\t\t.attr({\n\t\t\t\t\t\tid: val.id || null,\n\t\t\t\t\t\t\"class\": val.className\n\t\t\t\t\t\t\t? val.className\n\t\t\t\t\t\t\t: classes.cell + ' ' + klass\n\t\t\t\t\t})\n\t\t\t\t\t.append( val.contents )\n\t\t\t\t\t.appendTo( row );\n\t\t\t} );\n\t\t}\n\t}\n} );\n\n\nDataTable.feature = {};\n\n// Third parameter is internal only!\nDataTable.feature.register = function ( name, cb, legacy ) {\n\tDataTable.ext.features[ name ] = cb;\n\n\tif (legacy) {\n\t\t_ext.feature.push({\n\t\t\tcFeature: legacy,\n\t\t\tfnInit: cb\n\t\t});\n\t}\n};\n\nfunction _divProp(el, prop, val) {\n\tif (val) {\n\t\tel[prop] = val;\n\t}\n}\n\nDataTable.feature.register( 'div', function ( settings, opts ) {\n\tvar n = $('<div>')[0];\n\n\tif (opts) {\n\t\t_divProp(n, 'className', opts.className);\n\t\t_divProp(n, 'id', opts.id);\n\t\t_divProp(n, 'innerHTML', opts.html);\n\t\t_divProp(n, 'textContent', opts.text);\n\t}\n\n\treturn n;\n} );\n\nDataTable.feature.register( 'info', function ( settings, opts ) {\n\t// For compatibility with the legacy `info` top level option\n\tif (! settings.oFeatures.bInfo) {\n\t\treturn null;\n\t}\n\n\tvar\n\t\tlang  = settings.oLanguage,\n\t\ttid = settings.sTableId,\n\t\tn = $('<div/>', {\n\t\t\t'class': settings.oClasses.info.container,\n\t\t} );\n\n\topts = $.extend({\n\t\tcallback: lang.fnInfoCallback,\n\t\tempty: lang.sInfoEmpty,\n\t\tpostfix: lang.sInfoPostFix,\n\t\tsearch: lang.sInfoFiltered,\n\t\ttext: lang.sInfo,\n\t}, opts);\n\n\n\t// Update display on each draw\n\tsettings.aoDrawCallback.push(function (s) {\n\t\t_fnUpdateInfo(s, opts, n);\n\t});\n\n\t// For the first info display in the table, we add a callback and aria information.\n\tif (! settings._infoEl) {\n\t\tn.attr({\n\t\t\t'aria-live': 'polite',\n\t\t\tid: tid+'_info',\n\t\t\trole: 'status'\n\t\t});\n\n\t\t// Table is described by our info div\n\t\t$(settings.nTable).attr( 'aria-describedby', tid+'_info' );\n\n\t\tsettings._infoEl = n;\n\t}\n\n\treturn n;\n}, 'i' );\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, opts, node )\n{\n\tvar\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\t? opts.text\n\t\t\t: opts.empty;\n\n\tif ( total !== max ) {\n\t\t// Record set after filtering\n\t\tout += ' ' + opts.search;\n\t}\n\n\t// Convert the macros\n\tout += opts.postfix;\n\tout = _fnMacros( settings, out );\n\n\tif ( opts.callback ) {\n\t\tout = opts.callback.call( settings.oInstance,\n\t\t\tsettings, start, end, max, total, out\n\t\t);\n\t}\n\n\tnode.html( out );\n\n\t_fnCallbackFire(settings, null, 'info', [settings, node[0], out]);\n}\n\nvar __searchCounter = 0;\n\n// opts\n// - text\n// - placeholder\nDataTable.feature.register( 'search', function ( settings, opts ) {\n\t// Don't show the input if filtering isn't available on the table\n\tif (! settings.oFeatures.bFilter) {\n\t\treturn null;\n\t}\n\n\tvar classes = settings.oClasses.search;\n\tvar tableId = settings.sTableId;\n\tvar language = settings.oLanguage;\n\tvar previousSearch = settings.oPreviousSearch;\n\tvar input = '<input type=\"search\" class=\"'+classes.input+'\"/>';\n\n\topts = $.extend({\n\t\tplaceholder: language.sSearchPlaceholder,\n\t\tprocessing: false,\n\t\ttext: language.sSearch\n\t}, opts);\n\n\t// The _INPUT_ is optional - is appended if not present\n\tif (opts.text.indexOf('_INPUT_') === -1) {\n\t\topts.text += '_INPUT_';\n\t}\n\n\topts.text = _fnMacros(settings, opts.text);\n\n\t// We can put the <input> outside of the label if it is at the start or end\n\t// which helps improve accessability (not all screen readers like implicit\n\t// for elements).\n\tvar end = opts.text.match(/_INPUT_$/);\n\tvar start = opts.text.match(/^_INPUT_/);\n\tvar removed = opts.text.replace(/_INPUT_/, '');\n\tvar str = '<label>' + opts.text + '</label>';\n\n\tif (start) {\n\t\tstr = '_INPUT_<label>' + removed + '</label>';\n\t}\n\telse if (end) {\n\t\tstr = '<label>' + removed + '</label>_INPUT_';\n\t}\n\n\tvar filter = $('<div>')\n\t\t.addClass(classes.container)\n\t\t.append(str.replace(/_INPUT_/, input));\n\n\t// add for and id to label and input\n\tfilter.find('label').attr('for', 'dt-search-' + __searchCounter);\n\tfilter.find('input').attr('id', 'dt-search-' + __searchCounter);\n\t__searchCounter++;\n\n\tvar searchFn = function(event) {\n\t\tvar val = this.value;\n\n\t\tif(previousSearch.return && event.key !== \"Enter\") {\n\t\t\treturn;\n\t\t}\n\n\t\t/* Now do the filter */\n\t\tif ( val != previousSearch.search ) {\n\t\t\t_fnProcessingRun(settings, opts.processing, function () {\n\t\t\t\tpreviousSearch.search = val;\n\t\t\n\t\t\t\t_fnFilterComplete( settings, previousSearch );\n\t\t\n\t\t\t\t// Need to redraw, without resorting\n\t\t\t\tsettings._iDisplayStart = 0;\n\t\t\t\t_fnDraw( settings );\n\t\t\t});\n\t\t}\n\t};\n\n\tvar searchDelay = settings.searchDelay !== null ?\n\t\tsettings.searchDelay :\n\t\t0;\n\n\tvar jqFilter = $('input', filter)\n\t\t.val( previousSearch.search )\n\t\t.attr( 'placeholder', opts.placeholder )\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\tDataTable.util.debounce( 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 && jqFilter[0] !== document.activeElement ) {\n\t\t\tjqFilter.val( typeof previousSearch.search !== 'function'\n\t\t\t\t? previousSearch.search\n\t\t\t\t: ''\n\t\t\t);\n\t\t}\n\t} );\n\n\treturn filter;\n}, 'f' );\n\n// opts\n// - type - button configuration\n// - buttons - number of buttons to show - must be odd\nDataTable.feature.register( 'paging', function ( settings, opts ) {\n\t// Don't show the paging input if the table doesn't have paging enabled\n\tif (! settings.oFeatures.bPaginate) {\n\t\treturn null;\n\t}\n\n\topts = $.extend({\n\t\tbuttons: DataTable.ext.pager.numbers_length,\n\t\ttype: settings.sPaginationType,\n\t\tboundaryNumbers: true,\n\t\tfirstLast: true,\n\t\tpreviousNext: true,\n\t\tnumbers: true\n\t}, opts);\n\n\tvar host = $('<div/>')\n\t\t.addClass(settings.oClasses.paging.container + (opts.type ? ' paging_' + opts.type : ''))\n\t\t.append(\n\t\t\t$('<nav>')\n\t\t\t\t.attr('aria-label', 'pagination')\n\t\t\t\t.addClass(settings.oClasses.paging.nav)\n\t\t);\n\tvar draw = function () {\n\t\t_pagingDraw(settings, host.children(), opts);\n\t};\n\n\tsettings.aoDrawCallback.push(draw);\n\n\t// Responsive redraw of paging control\n\t$(settings.nTable).on('column-sizing.dt.DT', draw);\n\n\treturn host;\n}, 'p' );\n\n/**\n * Dynamically create the button type array based on the configuration options.\n * This will only happen if the paging type is not defined.\n */\nfunction _pagingDynamic(opts) {\n\tvar out = [];\n\n\tif (opts.numbers) {\n\t\tout.push('numbers');\n\t}\n\n\tif (opts.previousNext) {\n\t\tout.unshift('previous');\n\t\tout.push('next');\n\t}\n\n\tif (opts.firstLast) {\n\t\tout.unshift('first');\n\t\tout.push('last');\n\t}\n\n\treturn out;\n}\n\nfunction _pagingDraw(settings, host, opts) {\n\tif (! settings._bInitComplete) {\n\t\treturn;\n\t}\n\n\tvar\n\t\tplugin = opts.type\n\t\t\t? DataTable.ext.pager[ opts.type ]\n\t\t\t: _pagingDynamic,\n\t\taria = settings.oLanguage.oAria.paginate || {},\n\t\tstart      = settings._iDisplayStart,\n\t\tlen        = settings._iDisplayLength,\n\t\tvisRecords = settings.fnRecordsDisplay(),\n\t\tall        = len === -1,\n\t\tpage = all ? 0 : Math.ceil( start / len ),\n\t\tpages = all ? 1 : Math.ceil( visRecords / len ),\n\t\tbuttons = plugin(opts)\n\t\t\t.map(function (val) {\n\t\t\t\treturn val === 'numbers'\n\t\t\t\t\t? _pagingNumbers(page, pages, opts.buttons, opts.boundaryNumbers)\n\t\t\t\t\t: val;\n\t\t\t})\n\t\t\t.flat();\n\n\tvar buttonEls = [];\n\n\tfor (var i=0 ; i<buttons.length ; i++) {\n\t\tvar button = buttons[i];\n\n\t\tvar btnInfo = _pagingButtonInfo(settings, button, page, pages);\n\t\tvar btn = _fnRenderer( settings, 'pagingButton' )(\n\t\t\tsettings,\n\t\t\tbutton,\n\t\t\tbtnInfo.display,\n\t\t\tbtnInfo.active,\n\t\t\tbtnInfo.disabled\n\t\t);\n\n\t\tvar ariaLabel = typeof button === 'string'\n\t\t\t? aria[ button ]\n\t\t\t: aria.number\n\t\t\t\t? aria.number + (button+1)\n\t\t\t\t: null;\n\n\t\t// Common attributes\n\t\t$(btn.clicker).attr({\n\t\t\t'aria-controls': settings.sTableId,\n\t\t\t'aria-disabled': btnInfo.disabled ? 'true' : null,\n\t\t\t'aria-current': btnInfo.active ? 'page' : null,\n\t\t\t'aria-label': ariaLabel,\n\t\t\t'data-dt-idx': button,\n\t\t\t'tabIndex': btnInfo.disabled\n\t\t\t\t? -1\n\t\t\t\t: settings.iTabIndex\n\t\t\t\t\t? settings.iTabIndex\n\t\t\t\t\t: null, // `0` doesn't need a tabIndex since it is the default\n\t\t});\n\n\t\tif (typeof button !== 'number') {\n\t\t\t$(btn.clicker).addClass(button);\n\t\t}\n\n\t\t_fnBindAction(\n\t\t\tbtn.clicker, {action: button}, function(e) {\n\t\t\t\te.preventDefault();\n\n\t\t\t\t_fnPageChange( settings, e.data.action, true );\n\t\t\t}\n\t\t);\n\n\t\tbuttonEls.push(btn.display);\n\t}\n\n\tvar wrapped = _fnRenderer(settings, 'pagingContainer')(\n\t\tsettings, buttonEls\n\t);\n\n\tvar activeEl = host.find(document.activeElement).data('dt-idx');\n\n\thost.empty().append(wrapped);\n\n\tif ( activeEl !== undefined ) {\n\t\thost.find( '[data-dt-idx='+activeEl+']' ).trigger('focus');\n\t}\n\n\t// Responsive - check if the buttons are over two lines based on the\n\t// height of the buttons and the container.\n\tif (\n\t\tbuttonEls.length && // any buttons\n\t\topts.buttons > 1 && // prevent infinite\n\t\t$(host).height() >= ($(buttonEls[0]).outerHeight() * 2) - 10\n\t) {\n\t\t_pagingDraw(settings, host, $.extend({}, opts, { buttons: opts.buttons - 2 }));\n\t}\n}\n\n/**\n * Get properties for a button based on the current paging state of the table\n *\n * @param {*} settings DT settings object\n * @param {*} button The button type in question\n * @param {*} page Table's current page\n * @param {*} pages Number of pages\n * @returns Info object\n */\nfunction _pagingButtonInfo(settings, button, page, pages) {\n\tvar lang = settings.oLanguage.oPaginate;\n\tvar o = {\n\t\tdisplay: '',\n\t\tactive: false,\n\t\tdisabled: false\n\t};\n\n\tswitch ( button ) {\n\t\tcase 'ellipsis':\n\t\t\to.display = '&#x2026;';\n\t\t\to.disabled = true;\n\t\t\tbreak;\n\n\t\tcase 'first':\n\t\t\to.display = lang.sFirst;\n\n\t\t\tif (page === 0) {\n\t\t\t\to.disabled = true;\n\t\t\t}\n\t\t\tbreak;\n\n\t\tcase 'previous':\n\t\t\to.display = lang.sPrevious;\n\n\t\t\tif ( page === 0 ) {\n\t\t\t\to.disabled = true;\n\t\t\t}\n\t\t\tbreak;\n\n\t\tcase 'next':\n\t\t\to.display = lang.sNext;\n\n\t\t\tif ( pages === 0 || page === pages-1 ) {\n\t\t\t\to.disabled = true;\n\t\t\t}\n\t\t\tbreak;\n\n\t\tcase 'last':\n\t\t\to.display = lang.sLast;\n\n\t\t\tif ( pages === 0 || page === pages-1 ) {\n\t\t\t\to.disabled = true;\n\t\t\t}\n\t\t\tbreak;\n\n\t\tdefault:\n\t\t\tif ( typeof button === 'number' ) {\n\t\t\t\to.display = settings.fnFormatNumber( button + 1 );\n\t\t\t\t\n\t\t\t\tif (page === button) {\n\t\t\t\t\to.active = true;\n\t\t\t\t}\n\t\t\t}\n\t\t\tbreak;\n\t}\n\n\treturn o;\n}\n\n/**\n * Compute what number buttons to show in the paging control\n *\n * @param {*} page Current page\n * @param {*} pages Total number of pages\n * @param {*} buttons Target number of number buttons\n * @param {boolean} addFirstLast Indicate if page 1 and end should be included\n * @returns Buttons to show\n */\nfunction _pagingNumbers ( page, pages, buttons, addFirstLast ) {\n\tvar\n\t\tnumbers = [],\n\t\thalf = Math.floor(buttons / 2),\n\t\tbefore = addFirstLast ? 2 : 1,\n\t\tafter = addFirstLast ? 1 : 0;\n\n\tif ( pages <= buttons ) {\n\t\tnumbers = _range(0, pages);\n\t}\n\telse if (buttons === 1) {\n\t\t// Single button - current page only\n\t\tnumbers = [page];\n\t}\n\telse if (buttons === 3) {\n\t\t// Special logic for just three buttons\n\t\tif (page <= 1) {\n\t\t\tnumbers = [0, 1, 'ellipsis'];\n\t\t}\n\t\telse if (page >= pages - 2) {\n\t\t\tnumbers = _range(pages-2, pages);\n\t\t\tnumbers.unshift('ellipsis');\n\t\t}\n\t\telse {\n\t\t\tnumbers = ['ellipsis', page, 'ellipsis'];\n\t\t}\n\t}\n\telse if ( page <= half ) {\n\t\tnumbers = _range(0, buttons-before);\n\t\tnumbers.push('ellipsis');\n\n\t\tif (addFirstLast) {\n\t\t\tnumbers.push(pages-1);\n\t\t}\n\t}\n\telse if ( page >= pages - 1 - half ) {\n\t\tnumbers = _range(pages-(buttons-before), pages);\n\t\tnumbers.unshift('ellipsis');\n\n\t\tif (addFirstLast) {\n\t\t\tnumbers.unshift(0);\n\t\t}\n\t}\n\telse {\n\t\tnumbers = _range(page-half+before, page+half-after);\n\t\tnumbers.push('ellipsis');\n\t\tnumbers.unshift('ellipsis');\n\n\t\tif (addFirstLast) {\n\t\t\tnumbers.push(pages-1);\n\t\t\tnumbers.unshift(0);\n\t\t}\n\t}\n\n\treturn numbers;\n}\n\nvar __lengthCounter = 0;\n\n// opts\n// - menu\n// - text\nDataTable.feature.register( 'pageLength', function ( settings, opts ) {\n\tvar features = settings.oFeatures;\n\n\t// For compatibility with the legacy `pageLength` top level option\n\tif (! features.bPaginate || ! features.bLengthChange) {\n\t\treturn null;\n\t}\n\n\topts = $.extend({\n\t\tmenu: settings.aLengthMenu,\n\t\ttext: settings.oLanguage.sLengthMenu\n\t}, opts);\n\n\tvar\n\t\tclasses  = settings.oClasses.length,\n\t\ttableId  = settings.sTableId,\n\t\tmenu     = opts.menu,\n\t\tlengths  = [],\n\t\tlanguage = [],\n\t\ti;\n\n\t// Options can be given in a number of ways\n\tif (Array.isArray( menu[0] )) {\n\t\t// Old 1.x style - 2D array\n\t\tlengths = menu[0];\n\t\tlanguage = menu[1];\n\t}\n\telse {\n\t\tfor ( i=0 ; i<menu.length ; i++ ) {\n\t\t\t// An object with different label and value\n\t\t\tif ($.isPlainObject(menu[i])) {\n\t\t\t\tlengths.push(menu[i].value);\n\t\t\t\tlanguage.push(menu[i].label);\n\t\t\t}\n\t\t\telse {\n\t\t\t\t// Or just a number to display and use\n\t\t\t\tlengths.push(menu[i]);\n\t\t\t\tlanguage.push(menu[i]);\n\t\t\t}\n\t\t}\n\t}\n\n\t// We can put the <select> outside of the label if it is at the start or\n\t// end which helps improve accessability (not all screen readers like\n\t// implicit for elements).\n\tvar end = opts.text.match(/_MENU_$/);\n\tvar start = opts.text.match(/^_MENU_/);\n\tvar removed = opts.text.replace(/_MENU_/, '');\n\tvar str = '<label>' + opts.text + '</label>';\n\n\tif (start) {\n\t\tstr = '_MENU_<label>' + removed + '</label>';\n\t}\n\telse if (end) {\n\t\tstr = '<label>' + removed + '</label>_MENU_';\n\t}\n\n\t// Wrapper element - use a span as a holder for where the select will go\n\tvar tmpId = 'tmp-' + (+new Date())\n\tvar div = $('<div/>')\n\t\t.addClass( classes.container )\n\t\t.append(\n\t\t\tstr.replace( '_MENU_', '<span id=\"'+tmpId+'\"></span>' )\n\t\t);\n\n\t// Save text node content for macro updating\n\tvar textNodes = [];\n\tdiv.find('label')[0].childNodes.forEach(function (el) {\n\t\tif (el.nodeType === Node.TEXT_NODE) {\n\t\t\ttextNodes.push({\n\t\t\t\tel: el,\n\t\t\t\ttext: el.textContent\n\t\t\t});\n\t\t}\n\t})\n\n\t// Update the label text in case it has an entries value\n\tvar updateEntries = function (len) {\n\t\ttextNodes.forEach(function (node) {\n\t\t\tnode.el.textContent = _fnMacros(settings, node.text, len);\n\t\t});\n\t}\n\n\t// Next, the select itself, along with the options\n\tvar select = $('<select/>', {\n\t\t'name':          tableId+'_length',\n\t\t'aria-controls': tableId,\n\t\t'class':         classes.select\n\t} );\n\n\tfor ( i=0 ; i<lengths.length ; 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\t// add for and id to label and input\n\tdiv.find('label').attr('for', 'dt-length-' + __lengthCounter);\n\tselect.attr('id', 'dt-length-' + __lengthCounter);\n\t__lengthCounter++;\n\n\t// Swap in the select list\n\tdiv.find('#' + tmpId).replaceWith(select);\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() {\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\n\t\t\t// Resolve plurals in the text for the new length\n\t\t\tupdateEntries(len);\n\t\t}\n\t} );\n\n\tupdateEntries(settings._iDisplayLength);\n\n\treturn div;\n}, 'l' );\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","t","i","e","fn","dataTable","extend","ext","buttons","colvis","o","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","title","index","replace","Buttons","stripHtmlComments","util","stripHtml","trim","colvisRestore","every","__visOriginal","colvisGroup","show","hide","adjust","window","document","S","C","u","T","JSZip","s","pdfMake","k","sheetName","c","l","a","r","d","p","y","exportData","exportOptions","fieldBoundary","fieldSeparator","RegExp","escapeChar","f","header","headerStructure","join","footer","footerStructure","m","body","push","str","rows","navigator","userAgent","indexOf","match","jszip","N","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","O","charCodeAt","Math","floor","z","E","XMLSerializer","A","createElement","children","each","appendChild","createTextNode","D","ref","parseFloat","R","_","style","fmt","round","Date","parse","copyHtml5","exportInfo","css","height","width","overflow","position","top","left","messageTop","messageBottom","customize","val","appendTo","queryCommandSupported","table","container","focus","select","execCommand","copySuccess","info","append","closest","keyCode","async","csvHtml5","bom","available","charset","characterSet","filename","extension","excelHtml5","parseXML","createEmptyCells","row","forEach","colSpan","rowSpan","getElementsByTagName","_rels","xl","worksheets","I","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","customizeZip","generateAsync","then","generate","pdfHtml5","colspan","rowspan","pageSize","pageOrientation","orientation","headerRows","footerRows","layout","hLineWidth","vLineWidth","hLineColor","fillColor","paddingTop","paddingBottom","styles","tableHeader","bold","fontSize","alignment","tableFooter","margin","message","defaultStyle","unshift","createPdf","language","$","defaults","renderer","classes","search","input","processing","cell","tableCell","start","end","full","pagingButton","bootstrap","buttonType","disabled","btnClasses","li","addClass","display","clicker","role","html","pagingContainer","buttonEls","dom","collection","dropHtml","tag","spacer","dropdown","align","splitAlignClass","wrapper","buttonCreated","config","rightAlignClassName","_instCounter","_buttonCounter","_dtButtons","_entityDecoder","_fadeIn","el","duration","animate","stop","fadeIn","_fadeOut","fadeOut","_infoTimer","dt","versionCheck","Array","isArray","Api","listenKeys","_constructor","_nodeToButton","undefined","conf","flag","klass","jqNode","inCollection","hasClass","toggleClass","add","idx","draw","base","ien","_expandButton","_draw","newButtons","prefixButtons","apply","postfixButtons","newBtn","parentConf","disable","prop","slice","buttonInsts","inst","splice","enable","removeClass","nested","inner","triggerHandler","host","_nodeToHost","_removeKey","inArray","label","textNode","opt","that","dtSettings","_buttons","activeElement","character","toLowerCase","_keypress","_addKey","key","detach","inserter","attachTo","inSplit","attachPoint","isSplit","domCollection","_resolveExtends","built","_buildButton","_collection","j","item","parent","collectionLayout","dropup","fade","configDom","run","done","clickBlurs","iTabIndex","id","preventDefault","trigger","liner","enabled","titleAttr","splitDiv","buttonContainer","dropdownConf","wrapperConf","dropButtonConfig","splitAction","dropButton","stopPropagation","get","ret","_buttonsHandled","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","parents","lastChild","insertAfter","tableContainer","span","offsetParent","buttonPosition","buttonOffset","offset","tableSizes","containerPosition","computed","getComputedStyle","outerHeight","paddingLeft","right","bottom","popoverSizes","outerWidth","marginTop","marginBottom","scrollTop","place","half","backgroundHost","btn","back","addBack","target","filter","elements","first","last","insertPoint","instanceSelector","group","names","process","buttonSelector","insts","selector","nodeBuilder","baseIdx","stripData","stripHtmlScript","stripNewlines","decodeEntities","_exportTextarea","innerHTML","entityDecoder","previous","tabIndex","version","popover","copy","csv","excel","pdf","pageLength","lengthMenu","aLengthMenu","vals","lang","option","page","len","register","buttonGroup","res","iterator","ctx","_groupSelector","registerPlural","set","jq","groupSelector","containers","context","pluck","unique","time","clearTimeout","_exportData","_filename","_title","_message","_stringOrFunction","caption","modifier","order","orthogonal","format","customizeData","col","selected","any","rowIndexes","selectedCells","cells","render","cellNodes","cellIndexes","cellCounter","data","_headerFormatter","structure","formatter","struct","_init","api","opts","DataTable","oInit","feature","fnInit","cFeature","modal","_display","Responsive","_original","_modal","_bs","bs","Modal","update","closeCallback","rendered","contains","find","empty","one","childNodeStore","current","responsive","details","oldWindowWidth","innerWidth","_responsive","throttle","_resize","tr","to$","_setColumnVis","breakpoints","_classLogic","_detailsInit","_timer","_resizeAuto","_redrawChildren","curr","rowIds","child","isShown","_detailsDisplay","_controlClass","ready","_colGroupAttach","colGroup","colEls","found","parentNode","insertBefore","_childNodes","_childNodesRestore","store","parentChildren","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","aoColumns","sClass","columnIndex","rowIndex","forceRedraw","oldVis","collapsedClass","changed","colEl","_responsiveOnlyHidden","recordsDisplay","visibleColumns","clonedTable","cloneNode","clonedHeader","clonedFooter","clonedBody","clone","emptyRow","_responsiveMovesNodes","rowIdx2","removeAttr","inserted","clear","showHide","_setHeaderVis","isEmptyObject","_colspan","removeData","Infinity","childRow","rowNode","childRowImmediate","hasHidden","listHiddenNodes","ul","listHidden","tableAll","tableClass","json","RowGroup","rowGroup","existing","dataSrc","hostSettings","_adjustColspan","reduce","groupedRows","_group","_groupDisplay","level","fns","emptyDataGroup","dataPoint","groups","groupName","startRender","_rowWrap","startClassName","endRender","endClassName","_ext","_Api","_api_register","_api_registerPlural","factory","_that","emptyInit","iLen","_fnExtend","sId","$this","_fnCompatOpts","_fnCompatCols","_fnCamelToHungarian","allSettings","nTHead","nTFoot","bRetrieve","bDestroy","oInstance","_fnLog","sTableId","_unique","oSettings","models","colgroup","prependTo","fastData","_fnGetCellData","iDisplayLength","_fnMap","oFeatures","oLanguage","_fnCallbackReg","fnDrawCallback","fnStateSaveParams","fnStateLoadParams","fnStateLoaded","fnRowCallback","fnCreatedRow","fnHeaderCallback","fnFooterCallback","fnInitComplete","fnPreDrawCallback","rowIdFn","_fnGetObjectDataFn","rowId","__browser","browser","pageXOffset","outer","barWidth","clientWidth","bScrollbarLeft","oBrowser","_fnBrowserDetect","oClasses","bPaginate","iDisplayStart","iInitDisplayStart","_iDisplayStart","defer","iDeferLoading","deferLoading","tmp","_iRecordsDisplay","_iRecordsTotal","columnsInit","thead","initHeaderLayout","_fnDetectHeader","_fnAddColumn","aoColDefs","aoCols","headerLayout","jLen","kLen","def","sName","aTargets","targets","is","_fnApplyColumnDefs","aoColumnDefs","iCol","oDef","_fnColumnOptions","rowOne","mData","_isArrayHost","_fnSaveState","features","bStateSave","aaSorting","sorting","asSorting","_fnSortingClasses","bSorted","_fnDataSource","bDeferRender","_captionSide","captionNode","tbody","nTBody","tfoot","aiDisplay","aiDisplayMaster","bInitialised","sUrl","ajax","dataType","url","success","_fnCallbackFire","_fnInitialise","builder","errMode","legacy","pager","pageButton","detect","fnVersionCheck","iApiIndex","sVersion","afnFiltering","aTypes","ofnSearch","oSort","afnSortData","aoFeatures","oStdClasses","oPagination","tableRow","canAsc","canDesc","isAsc","isDesc","none","paging","nav","_re_dic","_re_new_lines","_re_html","_max_str_len","pow","_re_date","_re_escape_regex","_re_formatted_numeric","_empty","_intVal","integer","parseInt","isNaN","isFinite","_numToDecimal","num","decimalPoint","_fnEscapeRegex","_isNumber","formatted","allowEmpty","strType","_htmlNumeric","_isHtml","_stripHtml","_pluck","prop2","out","_pluck_order","_range","_removeEmpty","Error","_escapeHtml","_normalize","both","normalize","src","from","Set","sorted","_areAllUnique","again","_flatten","_addClass","classList","_fnHungarianMap","newKey","_hungarianMap","user","force","hungarianKey","charAt","diacritics","mixed","debounce","timeout","timer","args","arguments","freq","frequency","now","escapeRegex","source","meta","setData","arrayNotation","funcNotation","innerSrc","_fnSplitObjNotation","aLast","__reArray","__reFn","fetchData","substring","escapeHtml","_fnCompatMap","knew","old","sScrollX","scrollX","searchCols","aoSearchCols","oSearch","serverSide","searchDelay","dataSort","aDataSort","oDefaults","oCol","oColumn","searchFixed","aoPreSearchCols","oOptions","mDataProp","sType","_sManualType","origClass","iDataSort","mDataSrc","mRender","shift","_render","attrTest","_bAttrSrc","_setter","fnGetData","rowData","innerData","fnSetData","_fnSetObjectDataFn","_rowReadObject","bSort","bSortable","_fnAdjustColumnSizing","bAutoWidth","scroll","scrollY","scrollXInner","sXInner","_fnGetColumns","tableWidthAttr","styleWidth","tmpTable","_fnColumnsSumWidth","padding","border","longest","_fnGetMaxLenString","autoClass","sContentPadding","insert","holder","total","bodyCells","bounding","getBoundingClientRect","sWidth","_fnStringToCss","_reszEvt","sInstance","bindResize","_fnCalculateColumnWidths","cols","_fnColumnSizes","_fnScrollDraw","_fnVisibleToColumnIndex","iMatch","aiVis","_fnColumnIndexToVisible","iPos","_fnVisbleColumns","aoHeader","vis","bVisible","sParam","_typeResult","typeDetect","_fnColumnTypes","detectedType","cache","aoData","types","oneOf","allOf","_columnAutoClass","aoFooter","_columnAutoRender","nTr","displayData","_fnWriteCell","anCells","original","incVisible","_fnColumnsFromHeader","unit","sum","definedWidth","sWidthOrig","_fnAddData","dataIn","tds","rowModel","oRow","_aData","aIds","_fnCreateTr","_fnAddTr","trs","_fnGetRowElements","iDraw","defaultContent","sDefaultContent","cellData","iDrawError","fomatters","td","_fnGetDataMaster","_fnClearTable","_fnInvalidate","_aSortData","_aFilterData","_fnGetRowDisplay","maxLenString","_fnRowAttributes","contents","firstChild","objectRead","setter","cellProcess","toUpperCase","nextSibling","rowModal","iRow","nTrIn","anTds","nTd","create","trClass","_DT_RowIndex","sCellType","_DT_CellIndex","removeChild","fnCreatedCell","DT_RowClass","__rowc","DT_RowAttr","DT_RowData","_fnBuildHead","side","titleProp","detected","_fnRenderer","_fnHeaderLayout","incColumns","local","columnCount","includes","titleSpan","_fnDrawHead","point","_fnDraw","ajaxComplete","bServerSide","fnRecordsDisplay","_fnStart","anRows","iRowCount","iDisplayEnd","fnDisplayEnd","bDrawing","_fnProcessingDisplay","_emptyRow","_fnBuildAjax","preSearch","oPreviousSearch","preColSearch","colData","searchable","bSearchable","orderable","regex","fixed","Object","keys","term","_fnSortFlatten","dir","_iDisplayLength","_fnAjaxParameters","_fnAjaxDataSrc","_fnAjaxDataSrcParam","recordsTotal","recordsFiltered","_fnInitComplete","_fnAjaxUpdateDraw","iStart","iEnd","iDataIndex","nRow","replaceChildren","nTableWrapper","bFiltered","_fnReDraw","holdPosition","recompute","bFilter","_fnSort","_fnFilterComplete","_drawHold","oLang","zero","sZeroRecords","sLoadingRecords","sEmptyTable","fnRecordsTotal","_layoutItems","items","rowCell","rowClass","_layoutArray","pos","parts","rowNum","_layoutGetRow","order1","order2","reverse","_layoutResolve","getFeature","resolve","line","_fnAddOptionsHtml","sDom","featureNode","newNode","next","_fnFeatureHtmlTable","_fnLayoutDom","bProcessing","sProcessing","_processingHtml","write","shifted","isHeader","columnDef","sTitle","autoTitle","ariaTitle","setAttribute","ajaxData","instance","callback","status","jqXHR","sError","JSON","newData","baseAjax","sServerMethod","xhr","oAjaxData","dataProp","aaData","param","columnsSearch","filterData","wasInvalidated","__filter_div","__filter_div_textContent","textContent","innerText","_sFilterRow","_fnFilterData","_fnFilter","filters","displayRows","_fnFilterCustom","searchRows","searchFunc","rpSearch","not","boundary","caseInsensitive","exact","smart","word","negative","_fnFilterCreateSearch","loaded","state","_fnImplementState","fnStateLoadCallback","_fnLoadState","iAjaxStart","querySelectorAll","legacyTop","bSortCellsTop","notSelector","_fnSortAttachListener","_fnSortResolve","_fnSortInit","_colGroup","aData","_bInitComplete","_fnLengthChange","_fnLengthOverflow","_fnPageChange","redraw","records","_fnProcessingRun","captionSide","headerClone","footerClone","_div","scroller","scrollHead","scrollBody","scrollFoot","scrollLeft","bCollapse","nScrollHead","nScrollBody","nScrollFoot","aoDrawCallback","headerCopy","footerCopy","divHeaderInner","divHeaderTable","divBodyEl","divBody","divFooterInner","divFooterTable","scrollBarVis","scrollHeight","clientHeight","firstTr","colSizes","wrapAll","isScrolling","paddingSide","maxLen","cellString","nodeType","_fnBindAction","_fnSortAdd","_fnSortDisplay","master","masterMap","nestedSort","srcCol","aSort","extSort","aaSortingFixed","fixedObj","pre","post","_idx","sorter","aiOrig","displayMaster","_fnSortData","orderDescReverse","dataA","dataB","sortDetails","addIndex","nextSortIdx","bSortMulti","sortIdx","oldSort","aLastSort","sortClass","bSortClasses","customData","customSort","sSortDataType","_bLoadingState","oSavedState","fnStateSaveCallback","iStateDuration","oLoadedState","msg","tn","console","log","sErrMode","alert","mappedName","extender","breakRefs","hasOwnProperty","which","callbackArr","eventName","bubbles","Event","_fnMacros","entries","fnFormatNumber","all","ceil","__apiStruct","__arrayProto","_api_scope","scope","struc","methodExt","_api_find","ctxSettings","tables","_toSettings","flatten","alwaysNew","apiInst","_selector_row_indexes","apiSelector","lastIndexOf","pop","reduceRight","toJQuery","obj","__dt_wrapper","propExt","method","heir","pluralName","singularName","__table_selector","sel","visRecords","__reload","resetPaging","_selector_run","selectFn","selectorType","_selector_opts","_selector_first","displayFiltered","displayFilteredMap","ordered","selInt","cellIdx","rowObj","__row_selector","hash","newRows","modRows","idFn","ids","_detailsShow","childRows","__details_state_load","__details_state","__details_remove","_details","__details_display","__details_events","drawEvent","colvisEvent","destroyEvent","_child_obj","_child_mth","addRow","created","__details_add","__re_column_selector","__columnData","r1","r2","__column_header","titles","visColumns","jqResult","__column_selector","calc","__setColumnVis","widths","visIdx","rowSelector","columnSelector","allCells","fnSelector","__cell_selector","internalOpts","cellsNoOpts","columnVisible","directions","caseInsen","ignoreTime","setMutate","use","arg1","arg2","module","DateTime","__luxon","__moment","jquery","FixedOffsetZone","isMoment","root","version2","iThis","iThat","aThis","aThat","isDataTable","head","foot","camelToHungarian","jqRows","jqTable","jqTbody","jqWrapper","orderClasses","orig","removedMethod","sDestroyWidth","counter","selectedIdx","tableIdx","token","plural","resolved","toFormat","sThousands","sessionStorage","localStorage","getItem","pathname","setItem","stringify","paginate","number","topStart","topEnd","bottomStart","bottomEnd","pagingControls","extPagination","simple","numbers","simple_numbers","full_numbers","first_last","first_last_numbers","_numbers","_pagingNumbers","numbers_length","class","_filterString","__mld","dtLib","momentFn","luxonFn","dateFn","__mlWarning","__mldObj","locale","luxon","moment","utc","isValid","fromFormat","fromISO","setLocale","__mlHelper","localeString","to","typeName","valueOf","UTC","getFullYear","getMonth","getDate","getHours","getMinutes","getSeconds","__thousands","__decimal","Intl","NumberFormat","formatToParts","datetime","date","thousands","decimal","precision","prefix","postfix","flo","abs","exp","toExponential","toFixed","intPart","floatPart","_extTypes","asc","desc","setProp","propVal","setDetect","defineProperty","findIndex","setOrder","__diacriticSort","localeCompare","languages","numeric","ignorePunctuation","parsed","ts","sDecimal","dp","__numericReplace","decimalPlace","re1","re2","_divProp","ariaType","sortDirs","orderedColumns","isOrdering","orderDirs","firstVis","firstSort","sortOrder","cb","bInfo","tid","fnInfoCallback","sInfoEmpty","sInfoPostFix","sInfoFiltered","sInfo","_fnUpdateInfo","_infoEl","__searchCounter","_pagingDynamic","previousNext","firstLast","_pagingDraw","plugin","aria","oAria","pages","boundaryNumbers","flat","btnInfo","_pagingButtonInfo","ariaLabel","wrapped","activeEl","oPaginate","sFirst","sPrevious","sNext","sLast","addFirstLast","after","tableId","previousSearch","placeholder","sSearchPlaceholder","sSearch","removed","searchFn","return","jqFilter","ev","sPaginationType","__lengthCounter","bLengthChange","menu","sLengthMenu","lengths","tmpId","div","textNodes","Node","TEXT_NODE","updateEntries","Option","replaceWith","dataTableSettings","dataTableExt"],"sourceRoot":""}