{"version":3,"sources":["../node_modules/datatables.net-bs/js/dataTables.bootstrap.js","../node_modules/react-bootstrap/es/Col.js","../node_modules/react-bootstrap/es/Row.js","../node_modules/react-bootstrap/es/Table.js","../node_modules/datatables.net/js/jquery.dataTables.js"],"names":["__WEBPACK_AMD_DEFINE_ARRAY__","__WEBPACK_AMD_DEFINE_RESULT__","__webpack_require__","undefined","$","window","document","DataTable","fn","dataTable","extend","defaults","dom","renderer","ext","classes","sWrapper","sFilterInput","sLengthSelect","sProcessing","pageButton","bootstrap","settings","host","idx","buttons","page","pages","btnDisplay","btnClass","activeEl","api","Api","oClasses","lang","oLanguage","oPaginate","aria","oAria","paginate","counter","find","activeElement","data","e","attach","container","i","ien","node","button","clickHandler","preventDefault","currentTarget","hasClass","action","draw","length","isArray","sFirst","sPrevious","sNext","sLast","class","sPageButton","id","sTableId","append","href","aria-controls","aria-label","data-dt-idx","tabindex","iTabIndex","html","appendTo","oApi","_fnBindAction","empty","children","focus","factory","apply","exports","module","_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_0__","_babel_runtime_helpers_esm_objectWithoutPropertiesLoose__WEBPACK_IMPORTED_MODULE_1__","classnames__WEBPACK_IMPORTED_MODULE_2__","classnames__WEBPACK_IMPORTED_MODULE_2___default","n","react__WEBPACK_IMPORTED_MODULE_3__","react__WEBPACK_IMPORTED_MODULE_3___default","_ThemeProvider__WEBPACK_IMPORTED_MODULE_4__","DEVICE_SIZES","Col","a","forwardRef","_ref","ref","bsPrefix","className","_ref$as","as","Component","props","Object","prefix","spans","forEach","brkPoint","span","offset","order","propValue","_propValue$span","infix","push","createElement","concat","displayName","__webpack_exports__","_babel_runtime_helpers_esm_inheritsLoose__WEBPACK_IMPORTED_MODULE_2__","classnames__WEBPACK_IMPORTED_MODULE_3__","classnames__WEBPACK_IMPORTED_MODULE_3___default","react__WEBPACK_IMPORTED_MODULE_4__","react__WEBPACK_IMPORTED_MODULE_4___default","_ThemeProvider__WEBPACK_IMPORTED_MODULE_5__","Row","_React$Component","this","arguments","prototype","render","_this$props","noGutters","_this$props$as","defaultProps","Table","striped","bordered","borderless","hover","size","variant","responsive","table","responsiveClass","_ext","_Api2","_api_register","_api_registerPlural","options","sSelector","oOpts","_","rows","traditional","_fnSettingsFromNode","iApiIndex","fnAddData","redraw","isPlainObject","add","row","flatten","toArray","fnAdjustColumnSizing","bRedraw","columns","adjust","scroll","oScroll","sX","sY","_fnScrollDraw","fnClearTable","clear","fnClose","nTr","child","hide","fnDeleteRow","target","callback","aoData","remove","call","fnDestroy","destroy","fnDraw","complete","fnFilter","sInput","iColumn","bRegex","bSmart","bShowGlobal","bCaseInsensitive","search","column","fnGetData","src","col","type","nodeName","toLowerCase","cell","fnGetNodes","iRow","nodes","fnGetPosition","toUpperCase","index","columnVisible","fnIsOpen","isShown","fnOpen","mHtml","sClass","show","fnPageChange","mAction","fnSetColumnVis","iCol","bShow","visible","fnSettings","fnSort","aaSort","fnSortListener","nNode","fnCallback","listener","fnUpdate","mData","mRow","bAction","fnVersionCheck","_that","emptyInit","len","internal","_fnExternApiFunc","each","iLen","oInit","_fnExtend","sId","getAttribute","bInitHandedOff","$this","_fnCompatOpts","_fnCompatCols","_fnCamelToHungarian","allSettings","s","nTable","nTHead","parentNode","nTFoot","bRetrieve","bDestroy","oInstance","_fnLog","splice","_unique","oSettings","models","sDestroyWidth","style","width","sInstance","_fnLanguageCompat","aLengthMenu","iDisplayLength","_fnMap","oFeatures","_fnCallbackReg","fnDrawCallback","fnServerParams","fnStateSaveParams","fnStateLoadParams","fnStateLoaded","fnRowCallback","fnCreatedRow","fnHeaderCallback","fnFooterCallback","fnInitComplete","fnPreDrawCallback","rowIdFn","_fnGetObjectDataFn","rowId","_fnBrowserDetect","addClass","sTable","iInitDisplayStart","iDisplayStart","_iDisplayStart","iDeferLoading","bDeferLoading","tmp","_iRecordsDisplay","_iRecordsTotal","sUrl","ajax","dataType","url","success","json","_fnInitialise","error","asStripeClasses","sStripeOdd","sStripeEven","stripeClasses","rowOne","eq","inArray","map","el","removeClass","join","asDestroyStripes","slice","aoColumnsInit","anThs","nThead","getElementsByTagName","_fnDetectHeader","aoHeader","_fnGetUniqueThs","aoColumns","_fnAddColumn","_fnApplyColumnDefs","aoColumnDefs","oDef","_fnColumnOptions","name","sort","filter","features","loadedInit","aaSorting","sorting","asSorting","_fnSortingClasses","bSort","bSorted","aSort","_fnSortFlatten","sortedColumns","val","dir","_fnCallbackFire","_fnSortAria","_fnDataSource","bDeferRender","captions","_captionSide","css","thead","tbody","nTBody","tfoot","sNoFooter","aoFooter","aaData","_fnAddData","_fnAddTr","aiDisplay","aiDisplayMaster","bInitialised","bStateSave","_fnSaveState","_fnLoadState","_re_dic","_re_new_lines","_re_html","_re_date","_re_escape_regex","RegExp","_re_formatted_numeric","_empty","d","_intVal","integer","parseInt","isNaN","isFinite","_numToDecimal","num","decimalPoint","_fnEscapeRegex","replace","_isNumber","formatted","strType","parseFloat","_htmlNumeric","_isHtml","_stripHtml","_pluck","prop","prop2","out","_pluck_order","_range","start","end","_removeEmpty","sorted","last","_areAllUnique","j","k","again","_fnHungarianMap","o","match","newKey","key","indexOf","_hungarianMap","user","force","hungarianKey","charAt","defaultDecimal","sDecimal","_addNumericSort","zeroRecords","sZeroRecords","sEmptyTable","sLoadingRecords","sInfoThousands","sThousands","decimal","util","throttle","freq","timer","frequency","that","now","Date","args","clearTimeout","setTimeout","escapeRegex","_fnCompatMap","knew","old","init","sScrollX","scrollX","searchCols","aoSearchCols","oSearch","dataSort","aDataSort","__browser","browser","position","top","left","scrollLeft","height","overflow","outer","inner","barWidth","offsetWidth","clientWidth","bScrollOversize","bScrollbarLeft","Math","round","bBounding","getBoundingClientRect","oBrowser","iBarWidth","_fnReduce","inc","value","isSet","hasOwnProperty","nTh","oDefaults","oCol","oColumn","sTitle","innerHTML","aoPreSearchCols","oOptions","th","sWidthOrig","attr","t","mDataProp","sType","_sManualType","iDataSort","mDataSrc","mRender","attrTest","_bAttrSrc","_setter","rowData","meta","innerData","fnSetData","_fnSetObjectDataFn","_rowReadObject","bSortable","sSortableNone","bAsc","bDesc","sSortingClass","sSortableAsc","sSortingClassJUI","sSortJUIAscAllowed","sSortableDesc","sSortJUIDescAllowed","sSortable","sSortJUI","_fnAdjustColumnSizing","bAutoWidth","_fnCalculateColumnWidths","sWidth","_fnVisibleToColumnIndex","iMatch","aiVis","_fnGetColumns","_fnColumnIndexToVisible","iPos","_fnVisbleColumns","vis","bVisible","sParam","_fnColumnTypes","jen","ken","detectedType","cache","types","detect","_fnGetCellData","aoColDefs","aoCols","jLen","kLen","def","aTargets","targets","aDataIn","anTds","oData","oRow","_aData","aIds","_fnCreateTr","trs","_fnGetRowElements","cells","rowIdx","colIdx","iDraw","defaultContent","sDefaultContent","cellData","iDrawError","_fnSetCellData","__reArray","__reFn","_fnSplitObjNotation","str","mSource","fetchData","arrayNotation","funcNotation","innerSrc","substring","setData","b","aLast","_fnGetDataMaster","_fnClearTable","_fnDeleteIndex","iTarget","iTargetIndex","_fnInvalidate","cellWrite","childNodes","removeChild","firstChild","anCells","_aSortData","_aFilterData","cols","_fnRowAttributes","contents","tds","td","objectRead","setter","cellProcess","trim","nextSibling","rowNode","nTrIn","nTd","_DT_RowIndex","sCellType","_DT_CellIndex","appendChild","fnCreatedCell","setAttribute","tr","DT_RowClass","split","__rowc","DT_RowAttr","DT_RowData","_fnBuildHead","createHeader","_fnSortAttachListener","_fnRenderer","sHeaderTH","sFooterTH","nTf","_fnDrawHead","aoSource","bIncludeHidden","nLocalTr","iRowspan","iColspan","aoLocal","aApplied","iColumns","_fnDraw","aPreDraw","anRows","iRowCount","iStripes","oLang","aoOpenRows","bServerSide","bDrawing","fnRecordsDisplay","iDisplayEnd","fnDisplayEnd","_fnProcessingDisplay","bDestroying","_fnAjaxUpdate","iStart","iEnd","iDataIndex","nRow","sStripe","_sRowStripe","sZero","fnRecordsTotal","valign","colSpan","sRowEmpty","body","detach","bFiltered","_fnReDraw","holdPosition","bFilter","_fnSort","_fnFilterComplete","oPreviousSearch","_drawHold","_fnAddOptionsHtml","holding","insertBefore","insert","nHolding","nTableWrapper","nTableReinsertBefore","featureNode","cOption","nNewNode","cNext","sAttr","aDom","sDom","sJUIHeader","sJUIFooter","aSplit","substr","parent","bPaginate","bLengthChange","_fnFeatureHtmlLength","_fnFeatureHtmlFilter","bProcessing","_fnFeatureHtmlProcessing","_fnFeatureHtmlTable","bInfo","_fnFeatureHtmlInfo","_fnFeatureHtmlPaginate","feature","aoFeatures","cFeature","fnInit","aanFeatures","replaceWith","aLayout","nCell","l","iColShifted","bUnique","nTrs","fnShiftCol","unique","nHeader","aReturn","bSortCellsTop","_fnBuildAjax","rbracket","ajaxData","instance","jqXHR","newData","baseAjax","sError","sServerMethod","xhr","_error","thrown","ret","readyState","oAjaxData","fnServerData","sAjaxSource","bAjaxDataGet","_fnAjaxParameters","_fnAjaxUpdateDraw","dataProp","columnSearch","columnCount","preSearch","preColSearch","displayStart","displayLength","_iDisplayLength","param","sSearch","regex","sName","searchable","bSearchable","orderable","legacy","compat","modern","_fnAjaxDataSrc","recordsTotal","recordsFiltered","_bInitComplete","_fnInitComplete","dataSrc","sAjaxDataProp","tableId","language","previousSearch","input","f","sFilter","searchFn","searchDelay","jqFilter","sSearchPlaceholder","on","_fnThrottle","keyCode","ev","oInput","iForce","oPrevSearch","aoPrevSearch","fnSaveFilter","oFilter","fnRegex","bEscapeRegex","_fnFilter","_fnFilterColumn","_fnFilterCustom","filters","displayRows","merge","searchStr","smart","caseInsensitive","display","rpSearch","_fnFilterCreateSearch","test","invalidated","prevSearch","displayMaster","filtered","_fnFilterData","_sFilterRow","word","m","__filter_div","__filter_div_textContent","textContent","filterData","fomatters","wasInvalidated","toString","innerText","_fnSearchToCamel","obj","_fnSearchToHung","tid","sInfo","aoDrawCallback","_fnUpdateInfo","max","total","sInfoEmpty","sInfoFiltered","sInfoPostFix","_fnInfoMacros","fnInfoCallback","formatter","fnFormatNumber","all","ceil","iAjaxStart","deferLoading","_fnStringToCss","aData","_fnLengthChange","_fnLengthOverflow","menu","d2","lengths","select","Option","div","sLength","sLengthMenu","outerHTML","sPaginationType","plugin","pager","sPaging","p","visRecords","_fnPageChange","records","floor","changed","r","scrollY","caption","captionSide","headerClone","cloneNode","footerClone","footer","_div","scroller","sScrollWrapper","sScrollHead","border","sScrollHeadInner","box-sizing","sXInner","removeAttr","sScrollBody","sScrollFoot","sScrollFootInner","scrollHead","scrollBody","scrollFoot","bCollapse","nScrollHead","nScrollBody","nScrollFoot","headerTrgEls","footerTrgEls","headerSrcEls","footerSrcEls","headerCopy","footerCopy","correction","sanityWidth","scrollXInner","divHeader","divHeaderStyle","divHeaderInner","divHeaderInnerStyle","divHeaderTable","divBodyEl","divBody","divBodyStyle","divFooter","divFooterInner","divFooterTable","header","tableEl","tableStyle","ie67","dtHeaderCells","headerWidths","footerWidths","headerContent","footerContent","zeroOut","nSizer","paddingTop","paddingBottom","borderTopWidth","borderBottomWidth","scrollBarVis","scrollHeight","clientHeight","clone","prependTo","_fnApplyToChildren","outerWidth","offsetHeight","nToSize","iOuterWidth","bScrolling","padding","scrollTop","an1","an2","nNode1","nNode2","nodeType","__re_html_remove","columnIdx","visibleColumns","headerCells","tableWidthAttr","tableContainer","userInputs","styleWidth","_fnConvertToWidth","tmpTable","margin","_fnGetWidestNode","sContentPadding","holder","right","bounding","_reszEvt","bindResize","_fnGetMaxLenString","maxIdx","srcCol","fixed","aaSortingFixed","fixedObj","nestedSort","pre","post","_idx","sortCol","aiOrig","oExtSort","formatters","_fnSortData","x","y","dataA","dataB","label","nextSort","removeAttribute","sSortAscending","sSortDescending","_fnSortListener","nextSortIdx","next","bSortMulti","sortIdx","attachTo","shiftKey","oldSort","aLastSort","sortClass","sSortColumn","bSortClasses","customData","customSort","sSortDataType","state","time","oSavedState","fnStateSaveCallback","loaded","abStateLoad","duration","iStateDuration","oLoadedState","fnStateLoadCallback","level","msg","tn","console","log","sErrMode","errMode","alert","Error","mappedName","extender","breakRefs","blur","which","sStore","callbackArr","eventName","reverse","Event","trigger","result","__apiStruct","__arrayProto","Array","context","ctxSettings","mixed","jq","tables","_toSettings","selector","opts","any","count","ctx","iterator","alwaysNew","items","item","apiInst","_selector_row_indexes","apiSelector","lastIndexOf","pluck","pop","reduce","reduceRight","shift","to$","toJQuery","unshift","scope","__dt_wrapper","struct","methodScoping","struc","methodExt","propExt","register","method","heir","registerPlural","pluralName","singularName","__table_selector","paging","info","recordsDisplay","serverSide","__reload","one","abort","resetPaging","_selector_run","selectFn","res","selectorType","_selector_opts","_selector_first","inst","displayFiltered","displayFilteredMap","sel","selInt","cellIdx","closest","rowObj","__row_selector","hash","thatIdx","loopRow","loopCells","newRows","modRows","__details_remove","_details","_detailsShow","__details_display","insertAfter","__details_events","off","drawEvent","_child_obj","klass","addRow","created","__details_add","_child_mth","__re_column_selector","__columnData","r1","r2","names","visColumns","jqResult","__column_selector","calc","__setColumnVis","rowSelector","columnSelector","allCells","fnSelector","__cell_selector","set","caseInsen","versionCheck","version","iThis","iThat","aThis","aThat","isDataTable","fnIsDataTable","get","is","head","foot","fnTables","camelToHungarian","jqRows","orig","jqTable","jqTbody","jqWrapper","removedMethod","arg1","arg2","arg3","arg4","token","plural","resolved","bScrollCollapse","toFormat","JSON","parse","sessionStorage","localStorage","getItem","location","pathname","setItem","stringify","sScrollXInner","sScrollY","aoRowCallback","aoHeaderCallback","aoFooterCallback","aoRowCreatedCallback","aoPreDrawCallback","aoInitComplete","aoStateSaveParams","aoStateLoadParams","aoStateLoaded","aoStateSave","aoStateLoad","aoServerParams","aoDestroyCallback","min","oPlugins","builder","oJUIClasses","sVersion","afnFiltering","aTypes","ofnSearch","oSort","afnSortData","oStdClasses","oPagination","sPageButtonActive","sPageButtonDisabled","sSortAsc","sSortDesc","sSortJUIAsc","sSortJUIDesc","sSortJUIWrapper","sSortIcon","extPagination","_numbers","numbers","numbers_length","half","DT_el","simple","full","simple_numbers","full_numbers","first_last_numbers","parsed","string","__numericReplace","decimalPlace","re1","re2","Infinity","num-fmt","html-num","html-num-fmt","date-pre","ts","html-pre","string-pre","string-asc","string-desc","jqueryui","__htmlEscapeEntities","number","thousands","precision","postfix","negative","flo","toFixed","abs","intPart","floatPart","text","_fnNodeToDataIndex","_fnNodeToColumnIndex","_fnCalculateEnd","dataTableSettings","dataTableExt"],"mappings":"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","file":"static/js/10.b3dc2df8.chunk.js","sourcesContent":["/*! DataTables Bootstrap 3 integration\n * ©2011-2015 SpryMedia Ltd - datatables.net/license\n */\n\n/**\n * DataTables integration for Bootstrap 3. This requires Bootstrap 3 and\n * DataTables 1.10 or newer.\n *\n * This file sets the defaults and adds options to DataTables to style its\n * controls using Bootstrap. See http://datatables.net/manual/styling/bootstrap\n * for further information.\n */\n(function (factory) {\n  if (typeof define === 'function' && define.amd) {\n    // AMD\n    define(['jquery', 'datatables.net'], function ($) {\n      return factory($, window, document);\n    });\n  } else if (typeof exports === 'object') {\n    // CommonJS\n    module.exports = function (root, $) {\n      if (!root) {\n        root = window;\n      }\n\n      if (!$ || !$.fn.dataTable) {\n        // Require DataTables, which attaches to jQuery, including\n        // jQuery if needed and have a $ property so we can access the\n        // jQuery object that is used\n        $ = require('datatables.net')(root, $).$;\n      }\n\n      return factory($, root, root.document);\n    };\n  } else {\n    // Browser\n    factory(jQuery, window, document);\n  }\n})(function ($, window, document, undefined) {\n  'use strict';\n\n  var DataTable = $.fn.dataTable;\n  /* Set the defaults for DataTables initialisation */\n\n  $.extend(true, DataTable.defaults, {\n    dom: \"<'row'<'col-sm-6'l><'col-sm-6'f>>\" + \"<'row'<'col-sm-12'tr>>\" + \"<'row'<'col-sm-5'i><'col-sm-7'p>>\",\n    renderer: 'bootstrap'\n  });\n  /* Default class modification */\n\n  $.extend(DataTable.ext.classes, {\n    sWrapper: \"dataTables_wrapper form-inline dt-bootstrap\",\n    sFilterInput: \"form-control input-sm\",\n    sLengthSelect: \"form-control input-sm\",\n    sProcessing: \"dataTables_processing panel panel-default\"\n  });\n  /* Bootstrap paging button renderer */\n\n  DataTable.ext.renderer.pageButton.bootstrap = function (settings, host, idx, buttons, page, pages) {\n    var api = new DataTable.Api(settings);\n    var classes = settings.oClasses;\n    var lang = settings.oLanguage.oPaginate;\n    var aria = settings.oLanguage.oAria.paginate || {};\n    var btnDisplay,\n        btnClass,\n        counter = 0;\n\n    var attach = function attach(container, buttons) {\n      var i, ien, node, button;\n\n      var clickHandler = function clickHandler(e) {\n        e.preventDefault();\n\n        if (!$(e.currentTarget).hasClass('disabled') && api.page() != e.data.action) {\n          api.page(e.data.action).draw('page');\n        }\n      };\n\n      for (i = 0, ien = buttons.length; i < ien; i++) {\n        button = buttons[i];\n\n        if ($.isArray(button)) {\n          attach(container, button);\n        } else {\n          btnDisplay = '';\n          btnClass = '';\n\n          switch (button) {\n            case 'ellipsis':\n              btnDisplay = '&#x2026;';\n              btnClass = 'disabled';\n              break;\n\n            case 'first':\n              btnDisplay = lang.sFirst;\n              btnClass = button + (page > 0 ? '' : ' disabled');\n              break;\n\n            case 'previous':\n              btnDisplay = lang.sPrevious;\n              btnClass = button + (page > 0 ? '' : ' disabled');\n              break;\n\n            case 'next':\n              btnDisplay = lang.sNext;\n              btnClass = button + (page < pages - 1 ? '' : ' disabled');\n              break;\n\n            case 'last':\n              btnDisplay = lang.sLast;\n              btnClass = button + (page < pages - 1 ? '' : ' disabled');\n              break;\n\n            default:\n              btnDisplay = button + 1;\n              btnClass = page === button ? 'active' : '';\n              break;\n          }\n\n          if (btnDisplay) {\n            node = $('<li>', {\n              'class': classes.sPageButton + ' ' + btnClass,\n              'id': idx === 0 && typeof button === 'string' ? settings.sTableId + '_' + button : null\n            }).append($('<a>', {\n              'href': '#',\n              'aria-controls': settings.sTableId,\n              'aria-label': aria[button],\n              'data-dt-idx': counter,\n              'tabindex': settings.iTabIndex\n            }).html(btnDisplay)).appendTo(container);\n\n            settings.oApi._fnBindAction(node, {\n              action: button\n            }, clickHandler);\n\n            counter++;\n          }\n        }\n      }\n    }; // IE9 throws an 'unknown error' if document.activeElement is used\n    // inside an iframe or frame. \n\n\n    var activeEl;\n\n    try {\n      // Because this approach is destroying and recreating the paging\n      // elements, focus is lost on the select button which is bad for\n      // accessibility. So we want to restore focus once the draw has\n      // completed\n      activeEl = $(host).find(document.activeElement).data('dt-idx');\n    } catch (e) {}\n\n    attach($(host).empty().html('<ul class=\"pagination\"/>').children('ul'), buttons);\n\n    if (activeEl !== undefined) {\n      $(host).find('[data-dt-idx=' + activeEl + ']').focus();\n    }\n  };\n\n  return DataTable;\n});","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport classNames from 'classnames';\nimport React from 'react';\nimport { useBootstrapPrefix } from './ThemeProvider';\nvar DEVICE_SIZES = ['xl', 'lg', 'md', 'sm', 'xs'];\nvar Col = React.forwardRef( // Need to define the default \"as\" during prop destructuring to be compatible with styled-components github.com/react-bootstrap/react-bootstrap/issues/3595\nfunction (_ref, ref) {\n  var bsPrefix = _ref.bsPrefix,\n      className = _ref.className,\n      _ref$as = _ref.as,\n      Component = _ref$as === void 0 ? 'div' : _ref$as,\n      props = _objectWithoutPropertiesLoose(_ref, [\"bsPrefix\", \"className\", \"as\"]);\n\n  var prefix = useBootstrapPrefix(bsPrefix, 'col');\n  var spans = [];\n  var classes = [];\n  DEVICE_SIZES.forEach(function (brkPoint) {\n    var propValue = props[brkPoint];\n    delete props[brkPoint];\n    var span, offset, order;\n\n    if (propValue != null && typeof propValue === 'object') {\n      var _propValue$span = propValue.span;\n      span = _propValue$span === void 0 ? true : _propValue$span;\n      offset = propValue.offset;\n      order = propValue.order;\n    } else {\n      span = propValue;\n    }\n\n    var infix = brkPoint !== 'xs' ? \"-\" + brkPoint : '';\n    if (span != null) spans.push(span === true ? \"\" + prefix + infix : \"\" + prefix + infix + \"-\" + span);\n    if (order != null) classes.push(\"order\" + infix + \"-\" + order);\n    if (offset != null) classes.push(\"offset\" + infix + \"-\" + offset);\n  });\n\n  if (!spans.length) {\n    spans.push(prefix); // plain 'col'\n  }\n\n  return React.createElement(Component, _extends({}, props, {\n    ref: ref,\n    className: classNames.apply(void 0, [className].concat(spans, classes))\n  }));\n});\nCol.displayName = 'Col';\nexport default Col;","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _inheritsLoose from \"@babel/runtime/helpers/esm/inheritsLoose\";\nimport classNames from 'classnames';\nimport React from 'react';\nimport { createBootstrapComponent } from './ThemeProvider';\n\nvar Row =\n/*#__PURE__*/\nfunction (_React$Component) {\n  _inheritsLoose(Row, _React$Component);\n\n  function Row() {\n    return _React$Component.apply(this, arguments) || this;\n  }\n\n  var _proto = Row.prototype;\n\n  _proto.render = function render() {\n    var _this$props = this.props,\n        bsPrefix = _this$props.bsPrefix,\n        noGutters = _this$props.noGutters,\n        _this$props$as = _this$props.as,\n        Component = _this$props$as === void 0 ? 'div' : _this$props$as,\n        className = _this$props.className,\n        props = _objectWithoutPropertiesLoose(_this$props, [\"bsPrefix\", \"noGutters\", \"as\", \"className\"]);\n\n    return React.createElement(Component, _extends({}, props, {\n      className: classNames(className, bsPrefix, noGutters && 'no-gutters')\n    }));\n  };\n\n  return Row;\n}(React.Component);\n\nRow.defaultProps = {\n  noGutters: false\n};\nexport default createBootstrapComponent(Row, 'row');","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _inheritsLoose from \"@babel/runtime/helpers/esm/inheritsLoose\";\nimport classNames from 'classnames';\nimport React from 'react';\nimport { createBootstrapComponent } from './ThemeProvider';\n\nvar Table =\n/*#__PURE__*/\nfunction (_React$Component) {\n  _inheritsLoose(Table, _React$Component);\n\n  function Table() {\n    return _React$Component.apply(this, arguments) || this;\n  }\n\n  var _proto = Table.prototype;\n\n  _proto.render = function render() {\n    var _this$props = this.props,\n        bsPrefix = _this$props.bsPrefix,\n        className = _this$props.className,\n        striped = _this$props.striped,\n        bordered = _this$props.bordered,\n        borderless = _this$props.borderless,\n        hover = _this$props.hover,\n        size = _this$props.size,\n        variant = _this$props.variant,\n        responsive = _this$props.responsive,\n        props = _objectWithoutPropertiesLoose(_this$props, [\"bsPrefix\", \"className\", \"striped\", \"bordered\", \"borderless\", \"hover\", \"size\", \"variant\", \"responsive\"]);\n\n    var classes = classNames(bsPrefix, className, variant && bsPrefix + \"-\" + variant, size && bsPrefix + \"-\" + size, striped && bsPrefix + \"-striped\", bordered && bsPrefix + \"-bordered\", borderless && bsPrefix + \"-borderless\", hover && bsPrefix + \"-hover\");\n    var table = React.createElement(\"table\", _extends({}, props, {\n      className: classes\n    }));\n\n    if (responsive) {\n      var responsiveClass = bsPrefix + \"-responsive\";\n\n      if (typeof responsive === 'string') {\n        responsiveClass = responsiveClass + \"-\" + responsive;\n      }\n\n      return React.createElement(\"div\", {\n        className: responsiveClass\n      }, table);\n    }\n\n    return table;\n  };\n\n  return Table;\n}(React.Component);\n\nexport default createBootstrapComponent(Table, 'table');","/*! DataTables 1.10.19\n * ©2008-2018 SpryMedia Ltd - datatables.net/license\n */\n\n/**\n * @summary     DataTables\n * @description Paginate, search and order HTML tables\n * @version     1.10.19\n * @file        jquery.dataTables.js\n * @author      SpryMedia Ltd\n * @contact     www.datatables.net\n * @copyright   Copyright 2008-2018 SpryMedia Ltd.\n *\n * This source file is free software, available under the following license:\n *   MIT license - http://datatables.net/license\n *\n * This source file is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\n * or FITNESS FOR A PARTICULAR PURPOSE. See the license files for details.\n *\n * For details please refer to: http://www.datatables.net\n */\n\n/*jslint evil: true, undef: true, browser: true */\n\n/*globals $,require,jQuery,define,_selector_run,_selector_opts,_selector_first,_selector_row_indexes,_ext,_Api,_api_register,_api_registerPlural,_re_new_lines,_re_html,_re_formatted_numeric,_re_escape_regex,_empty,_intVal,_numToDecimal,_isNumber,_isHtml,_htmlNumeric,_pluck,_pluck_order,_range,_stripHtml,_unique,_fnBuildAjax,_fnAjaxUpdate,_fnAjaxParameters,_fnAjaxUpdateDraw,_fnAjaxDataSrc,_fnAddColumn,_fnColumnOptions,_fnAdjustColumnSizing,_fnVisibleToColumnIndex,_fnColumnIndexToVisible,_fnVisbleColumns,_fnGetColumns,_fnColumnTypes,_fnApplyColumnDefs,_fnHungarianMap,_fnCamelToHungarian,_fnLanguageCompat,_fnBrowserDetect,_fnAddData,_fnAddTr,_fnNodeToDataIndex,_fnNodeToColumnIndex,_fnGetCellData,_fnSetCellData,_fnSplitObjNotation,_fnGetObjectDataFn,_fnSetObjectDataFn,_fnGetDataMaster,_fnClearTable,_fnDeleteIndex,_fnInvalidate,_fnGetRowElements,_fnCreateTr,_fnBuildHead,_fnDrawHead,_fnDraw,_fnReDraw,_fnAddOptionsHtml,_fnDetectHeader,_fnGetUniqueThs,_fnFeatureHtmlFilter,_fnFilterComplete,_fnFilterCustom,_fnFilterColumn,_fnFilter,_fnFilterCreateSearch,_fnEscapeRegex,_fnFilterData,_fnFeatureHtmlInfo,_fnUpdateInfo,_fnInfoMacros,_fnInitialise,_fnInitComplete,_fnLengthChange,_fnFeatureHtmlLength,_fnFeatureHtmlPaginate,_fnPageChange,_fnFeatureHtmlProcessing,_fnProcessingDisplay,_fnFeatureHtmlTable,_fnScrollDraw,_fnApplyToChildren,_fnCalculateColumnWidths,_fnThrottle,_fnConvertToWidth,_fnGetWidestNode,_fnGetMaxLenString,_fnStringToCss,_fnSortFlatten,_fnSort,_fnSortAria,_fnSortListener,_fnSortAttachListener,_fnSortingClasses,_fnSortData,_fnSaveState,_fnLoadState,_fnSettingsFromNode,_fnLog,_fnMap,_fnBindAction,_fnCallbackReg,_fnCallbackFire,_fnLengthOverflow,_fnRenderer,_fnDataSource,_fnRowAttributes*/\n(function (factory) {\n  \"use strict\";\n\n  if (typeof define === 'function' && define.amd) {\n    // AMD\n    define(['jquery'], function ($) {\n      return factory($, window, document);\n    });\n  } else if (typeof exports === 'object') {\n    // CommonJS\n    module.exports = function (root, $) {\n      if (!root) {\n        // CommonJS environments without a window global must pass a\n        // root. This will give an error otherwise\n        root = window;\n      }\n\n      if (!$) {\n        $ = typeof window !== 'undefined' ? // jQuery's factory checks for a global window\n        require('jquery') : require('jquery')(root);\n      }\n\n      return factory($, root, root.document);\n    };\n  } else {\n    // Browser\n    factory(jQuery, window, document);\n  }\n})(function ($, window, document, undefined) {\n  \"use strict\";\n  /**\n   * DataTables is a plug-in for the jQuery Javascript library. It is a highly\n   * flexible tool, based upon the foundations of progressive enhancement,\n   * which will add advanced interaction controls to any HTML table. For a\n   * full list of features please refer to\n   * [DataTables.net](href=\"http://datatables.net).\n   *\n   * Note that the `DataTable` object is not a global variable but is aliased\n   * to `jQuery.fn.DataTable` and `jQuery.fn.dataTable` through which it may\n   * be  accessed.\n   *\n   *  @class\n   *  @param {object} [init={}] Configuration object for DataTables. Options\n   *    are defined by {@link DataTable.defaults}\n   *  @requires jQuery 1.7+\n   *\n   *  @example\n   *    // Basic initialisation\n   *    $(document).ready( function {\n   *      $('#example').dataTable();\n   *    } );\n   *\n   *  @example\n   *    // Initialisation with configuration options - in this case, disable\n   *    // pagination and sorting.\n   *    $(document).ready( function {\n   *      $('#example').dataTable( {\n   *        \"paginate\": false,\n   *        \"sort\": false\n   *      } );\n   *    } );\n   */\n\n  var DataTable = function DataTable(options) {\n    /**\n     * Perform a jQuery selector action on the table's TR elements (from the tbody) and\n     * return the resulting jQuery object.\n     *  @param {string|node|jQuery} sSelector jQuery selector or node collection to act on\n     *  @param {object} [oOpts] Optional parameters for modifying the rows to be included\n     *  @param {string} [oOpts.filter=none] Select TR elements that meet the current filter\n     *    criterion (\"applied\") or all TR elements (i.e. no filter).\n     *  @param {string} [oOpts.order=current] Order of the TR elements in the processed array.\n     *    Can be either 'current', whereby the current sorting of the table is used, or\n     *    'original' whereby the original order the data was read into the table is used.\n     *  @param {string} [oOpts.page=all] Limit the selection to the currently displayed page\n     *    (\"current\") or not (\"all\"). If 'current' is given, then order is assumed to be\n     *    'current' and filter is 'applied', regardless of what they might be given as.\n     *  @returns {object} jQuery object, filtered by the given selector.\n     *  @dtopt API\n     *  @deprecated Since v1.10\n     *\n     *  @example\n     *    $(document).ready(function() {\n     *      var oTable = $('#example').dataTable();\n     *\n     *      // Highlight every second row\n     *      oTable.$('tr:odd').css('backgroundColor', 'blue');\n     *    } );\n     *\n     *  @example\n     *    $(document).ready(function() {\n     *      var oTable = $('#example').dataTable();\n     *\n     *      // Filter to rows with 'Webkit' in them, add a background colour and then\n     *      // remove the filter, thus highlighting the 'Webkit' rows only.\n     *      oTable.fnFilter('Webkit');\n     *      oTable.$('tr', {\"search\": \"applied\"}).css('backgroundColor', 'blue');\n     *      oTable.fnFilter('');\n     *    } );\n     */\n    this.$ = function (sSelector, oOpts) {\n      return this.api(true).$(sSelector, oOpts);\n    };\n    /**\n     * Almost identical to $ in operation, but in this case returns the data for the matched\n     * rows - as such, the jQuery selector used should match TR row nodes or TD/TH cell nodes\n     * rather than any descendants, so the data can be obtained for the row/cell. If matching\n     * rows are found, the data returned is the original data array/object that was used to\n     * create the row (or a generated array if from a DOM source).\n     *\n     * This method is often useful in-combination with $ where both functions are given the\n     * same parameters and the array indexes will match identically.\n     *  @param {string|node|jQuery} sSelector jQuery selector or node collection to act on\n     *  @param {object} [oOpts] Optional parameters for modifying the rows to be included\n     *  @param {string} [oOpts.filter=none] Select elements that meet the current filter\n     *    criterion (\"applied\") or all elements (i.e. no filter).\n     *  @param {string} [oOpts.order=current] Order of the data in the processed array.\n     *    Can be either 'current', whereby the current sorting of the table is used, or\n     *    'original' whereby the original order the data was read into the table is used.\n     *  @param {string} [oOpts.page=all] Limit the selection to the currently displayed page\n     *    (\"current\") or not (\"all\"). If 'current' is given, then order is assumed to be\n     *    'current' and filter is 'applied', regardless of what they might be given as.\n     *  @returns {array} Data for the matched elements. If any elements, as a result of the\n     *    selector, were not TR, TD or TH elements in the DataTable, they will have a null\n     *    entry in the array.\n     *  @dtopt API\n     *  @deprecated Since v1.10\n     *\n     *  @example\n     *    $(document).ready(function() {\n     *      var oTable = $('#example').dataTable();\n     *\n     *      // Get the data from the first row in the table\n     *      var data = oTable._('tr:first');\n     *\n     *      // Do something useful with the data\n     *      alert( \"First cell is: \"+data[0] );\n     *    } );\n     *\n     *  @example\n     *    $(document).ready(function() {\n     *      var oTable = $('#example').dataTable();\n     *\n     *      // Filter to 'Webkit' and get all data for\n     *      oTable.fnFilter('Webkit');\n     *      var data = oTable._('tr', {\"search\": \"applied\"});\n     *\n     *      // Do something with the data\n     *      alert( data.length+\" rows matched the search\" );\n     *    } );\n     */\n\n\n    this._ = function (sSelector, oOpts) {\n      return this.api(true).rows(sSelector, oOpts).data();\n    };\n    /**\n     * Create a DataTables Api instance, with the currently selected tables for\n     * the Api's context.\n     * @param {boolean} [traditional=false] Set the API instance's context to be\n     *   only the table referred to by the `DataTable.ext.iApiIndex` option, as was\n     *   used in the API presented by DataTables 1.9- (i.e. the traditional mode),\n     *   or if all tables captured in the jQuery object should be used.\n     * @return {DataTables.Api}\n     */\n\n\n    this.api = function (traditional) {\n      return traditional ? new _Api2(_fnSettingsFromNode(this[_ext.iApiIndex])) : new _Api2(this);\n    };\n    /**\n     * Add a single new row or multiple rows of data to the table. Please note\n     * that this is suitable for client-side processing only - if you are using\n     * server-side processing (i.e. \"bServerSide\": true), then to add data, you\n     * must add it to the data source, i.e. the server-side, through an Ajax call.\n     *  @param {array|object} data The data to be added to the table. This can be:\n     *    <ul>\n     *      <li>1D array of data - add a single row with the data provided</li>\n     *      <li>2D array of arrays - add multiple rows in a single call</li>\n     *      <li>object - data object when using <i>mData</i></li>\n     *      <li>array of objects - multiple data objects when using <i>mData</i></li>\n     *    </ul>\n     *  @param {bool} [redraw=true] redraw the table or not\n     *  @returns {array} An array of integers, representing the list of indexes in\n     *    <i>aoData</i> ({@link DataTable.models.oSettings}) that have been added to\n     *    the table.\n     *  @dtopt API\n     *  @deprecated Since v1.10\n     *\n     *  @example\n     *    // Global var for counter\n     *    var giCount = 2;\n     *\n     *    $(document).ready(function() {\n     *      $('#example').dataTable();\n     *    } );\n     *\n     *    function fnClickAddRow() {\n     *      $('#example').dataTable().fnAddData( [\n     *        giCount+\".1\",\n     *        giCount+\".2\",\n     *        giCount+\".3\",\n     *        giCount+\".4\" ]\n     *      );\n     *\n     *      giCount++;\n     *    }\n     */\n\n\n    this.fnAddData = function (data, redraw) {\n      var api = this.api(true);\n      /* Check if we want to add multiple rows or not */\n\n      var rows = $.isArray(data) && ($.isArray(data[0]) || $.isPlainObject(data[0])) ? api.rows.add(data) : api.row.add(data);\n\n      if (redraw === undefined || redraw) {\n        api.draw();\n      }\n\n      return rows.flatten().toArray();\n    };\n    /**\n     * This function will make DataTables recalculate the column sizes, based on the data\n     * contained in the table and the sizes applied to the columns (in the DOM, CSS or\n     * through the sWidth parameter). This can be useful when the width of the table's\n     * parent element changes (for example a window resize).\n     *  @param {boolean} [bRedraw=true] Redraw the table or not, you will typically want to\n     *  @dtopt API\n     *  @deprecated Since v1.10\n     *\n     *  @example\n     *    $(document).ready(function() {\n     *      var oTable = $('#example').dataTable( {\n     *        \"sScrollY\": \"200px\",\n     *        \"bPaginate\": false\n     *      } );\n     *\n     *      $(window).on('resize', function () {\n     *        oTable.fnAdjustColumnSizing();\n     *      } );\n     *    } );\n     */\n\n\n    this.fnAdjustColumnSizing = function (bRedraw) {\n      var api = this.api(true).columns.adjust();\n      var settings = api.settings()[0];\n      var scroll = settings.oScroll;\n\n      if (bRedraw === undefined || bRedraw) {\n        api.draw(false);\n      } else if (scroll.sX !== \"\" || scroll.sY !== \"\") {\n        /* If not redrawing, but scrolling, we want to apply the new column sizes anyway */\n        _fnScrollDraw(settings);\n      }\n    };\n    /**\n     * Quickly and simply clear a table\n     *  @param {bool} [bRedraw=true] redraw the table or not\n     *  @dtopt API\n     *  @deprecated Since v1.10\n     *\n     *  @example\n     *    $(document).ready(function() {\n     *      var oTable = $('#example').dataTable();\n     *\n     *      // Immediately 'nuke' the current rows (perhaps waiting for an Ajax callback...)\n     *      oTable.fnClearTable();\n     *    } );\n     */\n\n\n    this.fnClearTable = function (bRedraw) {\n      var api = this.api(true).clear();\n\n      if (bRedraw === undefined || bRedraw) {\n        api.draw();\n      }\n    };\n    /**\n     * The exact opposite of 'opening' a row, this function will close any rows which\n     * are currently 'open'.\n     *  @param {node} nTr the table row to 'close'\n     *  @returns {int} 0 on success, or 1 if failed (can't find the row)\n     *  @dtopt API\n     *  @deprecated Since v1.10\n     *\n     *  @example\n     *    $(document).ready(function() {\n     *      var oTable;\n     *\n     *      // 'open' an information row when a row is clicked on\n     *      $('#example tbody tr').click( function () {\n     *        if ( oTable.fnIsOpen(this) ) {\n     *          oTable.fnClose( this );\n     *        } else {\n     *          oTable.fnOpen( this, \"Temporary row opened\", \"info_row\" );\n     *        }\n     *      } );\n     *\n     *      oTable = $('#example').dataTable();\n     *    } );\n     */\n\n\n    this.fnClose = function (nTr) {\n      this.api(true).row(nTr).child.hide();\n    };\n    /**\n     * Remove a row for the table\n     *  @param {mixed} target The index of the row from aoData to be deleted, or\n     *    the TR element you want to delete\n     *  @param {function|null} [callBack] Callback function\n     *  @param {bool} [redraw=true] Redraw the table or not\n     *  @returns {array} The row that was deleted\n     *  @dtopt API\n     *  @deprecated Since v1.10\n     *\n     *  @example\n     *    $(document).ready(function() {\n     *      var oTable = $('#example').dataTable();\n     *\n     *      // Immediately remove the first row\n     *      oTable.fnDeleteRow( 0 );\n     *    } );\n     */\n\n\n    this.fnDeleteRow = function (target, callback, redraw) {\n      var api = this.api(true);\n      var rows = api.rows(target);\n      var settings = rows.settings()[0];\n      var data = settings.aoData[rows[0][0]];\n      rows.remove();\n\n      if (callback) {\n        callback.call(this, settings, data);\n      }\n\n      if (redraw === undefined || redraw) {\n        api.draw();\n      }\n\n      return data;\n    };\n    /**\n     * Restore the table to it's original state in the DOM by removing all of DataTables\n     * enhancements, alterations to the DOM structure of the table and event listeners.\n     *  @param {boolean} [remove=false] Completely remove the table from the DOM\n     *  @dtopt API\n     *  @deprecated Since v1.10\n     *\n     *  @example\n     *    $(document).ready(function() {\n     *      // This example is fairly pointless in reality, but shows how fnDestroy can be used\n     *      var oTable = $('#example').dataTable();\n     *      oTable.fnDestroy();\n     *    } );\n     */\n\n\n    this.fnDestroy = function (remove) {\n      this.api(true).destroy(remove);\n    };\n    /**\n     * Redraw the table\n     *  @param {bool} [complete=true] Re-filter and resort (if enabled) the table before the draw.\n     *  @dtopt API\n     *  @deprecated Since v1.10\n     *\n     *  @example\n     *    $(document).ready(function() {\n     *      var oTable = $('#example').dataTable();\n     *\n     *      // Re-draw the table - you wouldn't want to do it here, but it's an example :-)\n     *      oTable.fnDraw();\n     *    } );\n     */\n\n\n    this.fnDraw = function (complete) {\n      // Note that this isn't an exact match to the old call to _fnDraw - it takes\n      // into account the new data, but can hold position.\n      this.api(true).draw(complete);\n    };\n    /**\n     * Filter the input based on data\n     *  @param {string} sInput String to filter the table on\n     *  @param {int|null} [iColumn] Column to limit filtering to\n     *  @param {bool} [bRegex=false] Treat as regular expression or not\n     *  @param {bool} [bSmart=true] Perform smart filtering or not\n     *  @param {bool} [bShowGlobal=true] Show the input global filter in it's input box(es)\n     *  @param {bool} [bCaseInsensitive=true] Do case-insensitive matching (true) or not (false)\n     *  @dtopt API\n     *  @deprecated Since v1.10\n     *\n     *  @example\n     *    $(document).ready(function() {\n     *      var oTable = $('#example').dataTable();\n     *\n     *      // Sometime later - filter...\n     *      oTable.fnFilter( 'test string' );\n     *    } );\n     */\n\n\n    this.fnFilter = function (sInput, iColumn, bRegex, bSmart, bShowGlobal, bCaseInsensitive) {\n      var api = this.api(true);\n\n      if (iColumn === null || iColumn === undefined) {\n        api.search(sInput, bRegex, bSmart, bCaseInsensitive);\n      } else {\n        api.column(iColumn).search(sInput, bRegex, bSmart, bCaseInsensitive);\n      }\n\n      api.draw();\n    };\n    /**\n     * Get the data for the whole table, an individual row or an individual cell based on the\n     * provided parameters.\n     *  @param {int|node} [src] A TR row node, TD/TH cell node or an integer. If given as\n     *    a TR node then the data source for the whole row will be returned. If given as a\n     *    TD/TH cell node then iCol will be automatically calculated and the data for the\n     *    cell returned. If given as an integer, then this is treated as the aoData internal\n     *    data index for the row (see fnGetPosition) and the data for that row used.\n     *  @param {int} [col] Optional column index that you want the data of.\n     *  @returns {array|object|string} If mRow is undefined, then the data for all rows is\n     *    returned. If mRow is defined, just data for that row, and is iCol is\n     *    defined, only data for the designated cell is returned.\n     *  @dtopt API\n     *  @deprecated Since v1.10\n     *\n     *  @example\n     *    // Row data\n     *    $(document).ready(function() {\n     *      oTable = $('#example').dataTable();\n     *\n     *      oTable.$('tr').click( function () {\n     *        var data = oTable.fnGetData( this );\n     *        // ... do something with the array / object of data for the row\n     *      } );\n     *    } );\n     *\n     *  @example\n     *    // Individual cell data\n     *    $(document).ready(function() {\n     *      oTable = $('#example').dataTable();\n     *\n     *      oTable.$('td').click( function () {\n     *        var sData = oTable.fnGetData( this );\n     *        alert( 'The cell clicked on had the value of '+sData );\n     *      } );\n     *    } );\n     */\n\n\n    this.fnGetData = function (src, col) {\n      var api = this.api(true);\n\n      if (src !== undefined) {\n        var type = src.nodeName ? src.nodeName.toLowerCase() : '';\n        return col !== undefined || type == 'td' || type == 'th' ? api.cell(src, col).data() : api.row(src).data() || null;\n      }\n\n      return api.data().toArray();\n    };\n    /**\n     * Get an array of the TR nodes that are used in the table's body. Note that you will\n     * typically want to use the '$' API method in preference to this as it is more\n     * flexible.\n     *  @param {int} [iRow] Optional row index for the TR element you want\n     *  @returns {array|node} If iRow is undefined, returns an array of all TR elements\n     *    in the table's body, or iRow is defined, just the TR element requested.\n     *  @dtopt API\n     *  @deprecated Since v1.10\n     *\n     *  @example\n     *    $(document).ready(function() {\n     *      var oTable = $('#example').dataTable();\n     *\n     *      // Get the nodes from the table\n     *      var nNodes = oTable.fnGetNodes( );\n     *    } );\n     */\n\n\n    this.fnGetNodes = function (iRow) {\n      var api = this.api(true);\n      return iRow !== undefined ? api.row(iRow).node() : api.rows().nodes().flatten().toArray();\n    };\n    /**\n     * Get the array indexes of a particular cell from it's DOM element\n     * and column index including hidden columns\n     *  @param {node} node this can either be a TR, TD or TH in the table's body\n     *  @returns {int} If nNode is given as a TR, then a single index is returned, or\n     *    if given as a cell, an array of [row index, column index (visible),\n     *    column index (all)] is given.\n     *  @dtopt API\n     *  @deprecated Since v1.10\n     *\n     *  @example\n     *    $(document).ready(function() {\n     *      $('#example tbody td').click( function () {\n     *        // Get the position of the current data from the node\n     *        var aPos = oTable.fnGetPosition( this );\n     *\n     *        // Get the data array for this row\n     *        var aData = oTable.fnGetData( aPos[0] );\n     *\n     *        // Update the data array and return the value\n     *        aData[ aPos[1] ] = 'clicked';\n     *        this.innerHTML = 'clicked';\n     *      } );\n     *\n     *      // Init DataTables\n     *      oTable = $('#example').dataTable();\n     *    } );\n     */\n\n\n    this.fnGetPosition = function (node) {\n      var api = this.api(true);\n      var nodeName = node.nodeName.toUpperCase();\n\n      if (nodeName == 'TR') {\n        return api.row(node).index();\n      } else if (nodeName == 'TD' || nodeName == 'TH') {\n        var cell = api.cell(node).index();\n        return [cell.row, cell.columnVisible, cell.column];\n      }\n\n      return null;\n    };\n    /**\n     * Check to see if a row is 'open' or not.\n     *  @param {node} nTr the table row to check\n     *  @returns {boolean} true if the row is currently open, false otherwise\n     *  @dtopt API\n     *  @deprecated Since v1.10\n     *\n     *  @example\n     *    $(document).ready(function() {\n     *      var oTable;\n     *\n     *      // 'open' an information row when a row is clicked on\n     *      $('#example tbody tr').click( function () {\n     *        if ( oTable.fnIsOpen(this) ) {\n     *          oTable.fnClose( this );\n     *        } else {\n     *          oTable.fnOpen( this, \"Temporary row opened\", \"info_row\" );\n     *        }\n     *      } );\n     *\n     *      oTable = $('#example').dataTable();\n     *    } );\n     */\n\n\n    this.fnIsOpen = function (nTr) {\n      return this.api(true).row(nTr).child.isShown();\n    };\n    /**\n     * This function will place a new row directly after a row which is currently\n     * on display on the page, with the HTML contents that is passed into the\n     * function. This can be used, for example, to ask for confirmation that a\n     * particular record should be deleted.\n     *  @param {node} nTr The table row to 'open'\n     *  @param {string|node|jQuery} mHtml The HTML to put into the row\n     *  @param {string} sClass Class to give the new TD cell\n     *  @returns {node} The row opened. Note that if the table row passed in as the\n     *    first parameter, is not found in the table, this method will silently\n     *    return.\n     *  @dtopt API\n     *  @deprecated Since v1.10\n     *\n     *  @example\n     *    $(document).ready(function() {\n     *      var oTable;\n     *\n     *      // 'open' an information row when a row is clicked on\n     *      $('#example tbody tr').click( function () {\n     *        if ( oTable.fnIsOpen(this) ) {\n     *          oTable.fnClose( this );\n     *        } else {\n     *          oTable.fnOpen( this, \"Temporary row opened\", \"info_row\" );\n     *        }\n     *      } );\n     *\n     *      oTable = $('#example').dataTable();\n     *    } );\n     */\n\n\n    this.fnOpen = function (nTr, mHtml, sClass) {\n      return this.api(true).row(nTr).child(mHtml, sClass).show().child()[0];\n    };\n    /**\n     * Change the pagination - provides the internal logic for pagination in a simple API\n     * function. With this function you can have a DataTables table go to the next,\n     * previous, first or last pages.\n     *  @param {string|int} mAction Paging action to take: \"first\", \"previous\", \"next\" or \"last\"\n     *    or page number to jump to (integer), note that page 0 is the first page.\n     *  @param {bool} [bRedraw=true] Redraw the table or not\n     *  @dtopt API\n     *  @deprecated Since v1.10\n     *\n     *  @example\n     *    $(document).ready(function() {\n     *      var oTable = $('#example').dataTable();\n     *      oTable.fnPageChange( 'next' );\n     *    } );\n     */\n\n\n    this.fnPageChange = function (mAction, bRedraw) {\n      var api = this.api(true).page(mAction);\n\n      if (bRedraw === undefined || bRedraw) {\n        api.draw(false);\n      }\n    };\n    /**\n     * Show a particular column\n     *  @param {int} iCol The column whose display should be changed\n     *  @param {bool} bShow Show (true) or hide (false) the column\n     *  @param {bool} [bRedraw=true] Redraw the table or not\n     *  @dtopt API\n     *  @deprecated Since v1.10\n     *\n     *  @example\n     *    $(document).ready(function() {\n     *      var oTable = $('#example').dataTable();\n     *\n     *      // Hide the second column after initialisation\n     *      oTable.fnSetColumnVis( 1, false );\n     *    } );\n     */\n\n\n    this.fnSetColumnVis = function (iCol, bShow, bRedraw) {\n      var api = this.api(true).column(iCol).visible(bShow);\n\n      if (bRedraw === undefined || bRedraw) {\n        api.columns.adjust().draw();\n      }\n    };\n    /**\n     * Get the settings for a particular table for external manipulation\n     *  @returns {object} DataTables settings object. See\n     *    {@link DataTable.models.oSettings}\n     *  @dtopt API\n     *  @deprecated Since v1.10\n     *\n     *  @example\n     *    $(document).ready(function() {\n     *      var oTable = $('#example').dataTable();\n     *      var oSettings = oTable.fnSettings();\n     *\n     *      // Show an example parameter from the settings\n     *      alert( oSettings._iDisplayStart );\n     *    } );\n     */\n\n\n    this.fnSettings = function () {\n      return _fnSettingsFromNode(this[_ext.iApiIndex]);\n    };\n    /**\n     * Sort the table by a particular column\n     *  @param {int} iCol the data index to sort on. Note that this will not match the\n     *    'display index' if you have hidden data entries\n     *  @dtopt API\n     *  @deprecated Since v1.10\n     *\n     *  @example\n     *    $(document).ready(function() {\n     *      var oTable = $('#example').dataTable();\n     *\n     *      // Sort immediately with columns 0 and 1\n     *      oTable.fnSort( [ [0,'asc'], [1,'asc'] ] );\n     *    } );\n     */\n\n\n    this.fnSort = function (aaSort) {\n      this.api(true).order(aaSort).draw();\n    };\n    /**\n     * Attach a sort listener to an element for a given column\n     *  @param {node} nNode the element to attach the sort listener to\n     *  @param {int} iColumn the column that a click on this node will sort on\n     *  @param {function} [fnCallback] callback function when sort is run\n     *  @dtopt API\n     *  @deprecated Since v1.10\n     *\n     *  @example\n     *    $(document).ready(function() {\n     *      var oTable = $('#example').dataTable();\n     *\n     *      // Sort on column 1, when 'sorter' is clicked on\n     *      oTable.fnSortListener( document.getElementById('sorter'), 1 );\n     *    } );\n     */\n\n\n    this.fnSortListener = function (nNode, iColumn, fnCallback) {\n      this.api(true).order.listener(nNode, iColumn, fnCallback);\n    };\n    /**\n     * Update a table cell or row - this method will accept either a single value to\n     * update the cell with, an array of values with one element for each column or\n     * an object in the same format as the original data source. The function is\n     * self-referencing in order to make the multi column updates easier.\n     *  @param {object|array|string} mData Data to update the cell/row with\n     *  @param {node|int} mRow TR element you want to update or the aoData index\n     *  @param {int} [iColumn] The column to update, give as null or undefined to\n     *    update a whole row.\n     *  @param {bool} [bRedraw=true] Redraw the table or not\n     *  @param {bool} [bAction=true] Perform pre-draw actions or not\n     *  @returns {int} 0 on success, 1 on error\n     *  @dtopt API\n     *  @deprecated Since v1.10\n     *\n     *  @example\n     *    $(document).ready(function() {\n     *      var oTable = $('#example').dataTable();\n     *      oTable.fnUpdate( 'Example update', 0, 0 ); // Single cell\n     *      oTable.fnUpdate( ['a', 'b', 'c', 'd', 'e'], $('tbody tr')[0] ); // Row\n     *    } );\n     */\n\n\n    this.fnUpdate = function (mData, mRow, iColumn, bRedraw, bAction) {\n      var api = this.api(true);\n\n      if (iColumn === undefined || iColumn === null) {\n        api.row(mRow).data(mData);\n      } else {\n        api.cell(mRow, iColumn).data(mData);\n      }\n\n      if (bAction === undefined || bAction) {\n        api.columns.adjust();\n      }\n\n      if (bRedraw === undefined || bRedraw) {\n        api.draw();\n      }\n\n      return 0;\n    };\n    /**\n     * Provide a common method for plug-ins to check the version of DataTables being used, in order\n     * to ensure compatibility.\n     *  @param {string} sVersion Version string to check for, in the format \"X.Y.Z\". Note that the\n     *    formats \"X\" and \"X.Y\" are also acceptable.\n     *  @returns {boolean} true if this version of DataTables is greater or equal to the required\n     *    version, or false if this version of DataTales is not suitable\n     *  @method\n     *  @dtopt API\n     *  @deprecated Since v1.10\n     *\n     *  @example\n     *    $(document).ready(function() {\n     *      var oTable = $('#example').dataTable();\n     *      alert( oTable.fnVersionCheck( '1.9.0' ) );\n     *    } );\n     */\n\n\n    this.fnVersionCheck = _ext.fnVersionCheck;\n\n    var _that = this;\n\n    var emptyInit = options === undefined;\n    var len = this.length;\n\n    if (emptyInit) {\n      options = {};\n    }\n\n    this.oApi = this.internal = _ext.internal; // Extend with old style plug-in API methods\n\n    for (var fn in DataTable.ext.internal) {\n      if (fn) {\n        this[fn] = _fnExternApiFunc(fn);\n      }\n    }\n\n    this.each(function () {\n      // For each initialisation we want to give it a clean initialisation\n      // object that can be bashed around\n      var o = {};\n      var oInit = len > 1 ? // optimisation for single table case\n      _fnExtend(o, options, true) : options;\n      /*global oInit,_that,emptyInit*/\n\n      var i = 0,\n          iLen,\n          j,\n          jLen,\n          k,\n          kLen;\n      var sId = this.getAttribute('id');\n      var bInitHandedOff = false;\n      var defaults = DataTable.defaults;\n      var $this = $(this);\n      /* Sanity check */\n\n      if (this.nodeName.toLowerCase() != 'table') {\n        _fnLog(null, 0, 'Non-table node initialisation (' + this.nodeName + ')', 2);\n\n        return;\n      }\n      /* Backwards compatibility for the defaults */\n\n\n      _fnCompatOpts(defaults);\n\n      _fnCompatCols(defaults.column);\n      /* Convert the camel-case defaults to Hungarian */\n\n\n      _fnCamelToHungarian(defaults, defaults, true);\n\n      _fnCamelToHungarian(defaults.column, defaults.column, true);\n      /* Setting up the initialisation object */\n\n\n      _fnCamelToHungarian(defaults, $.extend(oInit, $this.data()));\n      /* Check to see if we are re-initialising a table */\n\n\n      var allSettings = DataTable.settings;\n\n      for (i = 0, iLen = allSettings.length; i < iLen; i++) {\n        var s = allSettings[i];\n        /* Base check on table node */\n\n        if (s.nTable == this || s.nTHead && s.nTHead.parentNode == this || s.nTFoot && s.nTFoot.parentNode == this) {\n          var bRetrieve = oInit.bRetrieve !== undefined ? oInit.bRetrieve : defaults.bRetrieve;\n          var bDestroy = oInit.bDestroy !== undefined ? oInit.bDestroy : defaults.bDestroy;\n\n          if (emptyInit || bRetrieve) {\n            return s.oInstance;\n          } else if (bDestroy) {\n            s.oInstance.fnDestroy();\n            break;\n          } else {\n            _fnLog(s, 0, 'Cannot reinitialise DataTable', 3);\n\n            return;\n          }\n        }\n        /* If the element we are initialising has the same ID as a table which was previously\n         * initialised, but the table nodes don't match (from before) then we destroy the old\n         * instance by simply deleting it. This is under the assumption that the table has been\n         * destroyed by other methods. Anyone using non-id selectors will need to do this manually\n         */\n\n\n        if (s.sTableId == this.id) {\n          allSettings.splice(i, 1);\n          break;\n        }\n      }\n      /* Ensure the table has an ID - required for accessibility */\n\n\n      if (sId === null || sId === \"\") {\n        sId = \"DataTables_Table_\" + DataTable.ext._unique++;\n        this.id = sId;\n      }\n      /* Create the settings object for this table and set some of the default parameters */\n\n\n      var oSettings = $.extend(true, {}, DataTable.models.oSettings, {\n        \"sDestroyWidth\": $this[0].style.width,\n        \"sInstance\": sId,\n        \"sTableId\": sId\n      });\n      oSettings.nTable = this;\n      oSettings.oApi = _that.internal;\n      oSettings.oInit = oInit;\n      allSettings.push(oSettings); // Need to add the instance after the instance after the settings object has been added\n      // to the settings array, so we can self reference the table instance if more than one\n\n      oSettings.oInstance = _that.length === 1 ? _that : $this.dataTable(); // Backwards compatibility, before we apply all the defaults\n\n      _fnCompatOpts(oInit);\n\n      _fnLanguageCompat(oInit.oLanguage); // If the length menu is given, but the init display length is not, use the length menu\n\n\n      if (oInit.aLengthMenu && !oInit.iDisplayLength) {\n        oInit.iDisplayLength = $.isArray(oInit.aLengthMenu[0]) ? oInit.aLengthMenu[0][0] : oInit.aLengthMenu[0];\n      } // Apply the defaults and init options to make a single init object will all\n      // options defined from defaults and instance options.\n\n\n      oInit = _fnExtend($.extend(true, {}, defaults), oInit); // Map the initialisation options onto the settings object\n\n      _fnMap(oSettings.oFeatures, oInit, [\"bPaginate\", \"bLengthChange\", \"bFilter\", \"bSort\", \"bSortMulti\", \"bInfo\", \"bProcessing\", \"bAutoWidth\", \"bSortClasses\", \"bServerSide\", \"bDeferRender\"]);\n\n      _fnMap(oSettings, oInit, [\"asStripeClasses\", \"ajax\", \"fnServerData\", \"fnFormatNumber\", \"sServerMethod\", \"aaSorting\", \"aaSortingFixed\", \"aLengthMenu\", \"sPaginationType\", \"sAjaxSource\", \"sAjaxDataProp\", \"iStateDuration\", \"sDom\", \"bSortCellsTop\", \"iTabIndex\", \"fnStateLoadCallback\", \"fnStateSaveCallback\", \"renderer\", \"searchDelay\", \"rowId\", [\"iCookieDuration\", \"iStateDuration\"], // backwards compat\n      [\"oSearch\", \"oPreviousSearch\"], [\"aoSearchCols\", \"aoPreSearchCols\"], [\"iDisplayLength\", \"_iDisplayLength\"]]);\n\n      _fnMap(oSettings.oScroll, oInit, [[\"sScrollX\", \"sX\"], [\"sScrollXInner\", \"sXInner\"], [\"sScrollY\", \"sY\"], [\"bScrollCollapse\", \"bCollapse\"]]);\n\n      _fnMap(oSettings.oLanguage, oInit, \"fnInfoCallback\");\n      /* Callback functions which are array driven */\n\n\n      _fnCallbackReg(oSettings, 'aoDrawCallback', oInit.fnDrawCallback, 'user');\n\n      _fnCallbackReg(oSettings, 'aoServerParams', oInit.fnServerParams, 'user');\n\n      _fnCallbackReg(oSettings, 'aoStateSaveParams', oInit.fnStateSaveParams, 'user');\n\n      _fnCallbackReg(oSettings, 'aoStateLoadParams', oInit.fnStateLoadParams, 'user');\n\n      _fnCallbackReg(oSettings, 'aoStateLoaded', oInit.fnStateLoaded, 'user');\n\n      _fnCallbackReg(oSettings, 'aoRowCallback', oInit.fnRowCallback, 'user');\n\n      _fnCallbackReg(oSettings, 'aoRowCreatedCallback', oInit.fnCreatedRow, 'user');\n\n      _fnCallbackReg(oSettings, 'aoHeaderCallback', oInit.fnHeaderCallback, 'user');\n\n      _fnCallbackReg(oSettings, 'aoFooterCallback', oInit.fnFooterCallback, 'user');\n\n      _fnCallbackReg(oSettings, 'aoInitComplete', oInit.fnInitComplete, 'user');\n\n      _fnCallbackReg(oSettings, 'aoPreDrawCallback', oInit.fnPreDrawCallback, 'user');\n\n      oSettings.rowIdFn = _fnGetObjectDataFn(oInit.rowId);\n      /* Browser support detection */\n\n      _fnBrowserDetect(oSettings);\n\n      var oClasses = oSettings.oClasses;\n      $.extend(oClasses, DataTable.ext.classes, oInit.oClasses);\n      $this.addClass(oClasses.sTable);\n\n      if (oSettings.iInitDisplayStart === undefined) {\n        /* Display start point, taking into account the save saving */\n        oSettings.iInitDisplayStart = oInit.iDisplayStart;\n        oSettings._iDisplayStart = oInit.iDisplayStart;\n      }\n\n      if (oInit.iDeferLoading !== null) {\n        oSettings.bDeferLoading = true;\n        var tmp = $.isArray(oInit.iDeferLoading);\n        oSettings._iRecordsDisplay = tmp ? oInit.iDeferLoading[0] : oInit.iDeferLoading;\n        oSettings._iRecordsTotal = tmp ? oInit.iDeferLoading[1] : oInit.iDeferLoading;\n      }\n      /* Language definitions */\n\n\n      var oLanguage = oSettings.oLanguage;\n      $.extend(true, oLanguage, oInit.oLanguage);\n\n      if (oLanguage.sUrl) {\n        /* Get the language definitions from a file - because this Ajax call makes the language\n         * get async to the remainder of this function we use bInitHandedOff to indicate that\n         * _fnInitialise will be fired by the returned Ajax handler, rather than the constructor\n         */\n        $.ajax({\n          dataType: 'json',\n          url: oLanguage.sUrl,\n          success: function success(json) {\n            _fnLanguageCompat(json);\n\n            _fnCamelToHungarian(defaults.oLanguage, json);\n\n            $.extend(true, oLanguage, json);\n\n            _fnInitialise(oSettings);\n          },\n          error: function error() {\n            // Error occurred loading language file, continue on as best we can\n            _fnInitialise(oSettings);\n          }\n        });\n        bInitHandedOff = true;\n      }\n      /*\n       * Stripes\n       */\n\n\n      if (oInit.asStripeClasses === null) {\n        oSettings.asStripeClasses = [oClasses.sStripeOdd, oClasses.sStripeEven];\n      }\n      /* Remove row stripe classes if they are already on the table row */\n\n\n      var stripeClasses = oSettings.asStripeClasses;\n      var rowOne = $this.children('tbody').find('tr').eq(0);\n\n      if ($.inArray(true, $.map(stripeClasses, function (el, i) {\n        return rowOne.hasClass(el);\n      })) !== -1) {\n        $('tbody tr', this).removeClass(stripeClasses.join(' '));\n        oSettings.asDestroyStripes = stripeClasses.slice();\n      }\n      /*\n       * Columns\n       * See if we should load columns automatically or use defined ones\n       */\n\n\n      var anThs = [];\n      var aoColumnsInit;\n      var nThead = this.getElementsByTagName('thead');\n\n      if (nThead.length !== 0) {\n        _fnDetectHeader(oSettings.aoHeader, nThead[0]);\n\n        anThs = _fnGetUniqueThs(oSettings);\n      }\n      /* If not given a column array, generate one with nulls */\n\n\n      if (oInit.aoColumns === null) {\n        aoColumnsInit = [];\n\n        for (i = 0, iLen = anThs.length; i < iLen; i++) {\n          aoColumnsInit.push(null);\n        }\n      } else {\n        aoColumnsInit = oInit.aoColumns;\n      }\n      /* Add the columns */\n\n\n      for (i = 0, iLen = aoColumnsInit.length; i < iLen; i++) {\n        _fnAddColumn(oSettings, anThs ? anThs[i] : null);\n      }\n      /* Apply the column definitions */\n\n\n      _fnApplyColumnDefs(oSettings, oInit.aoColumnDefs, aoColumnsInit, function (iCol, oDef) {\n        _fnColumnOptions(oSettings, iCol, oDef);\n      });\n      /* HTML5 attribute detection - build an mData object automatically if the\n       * attributes are found\n       */\n\n\n      if (rowOne.length) {\n        var a = function a(cell, name) {\n          return cell.getAttribute('data-' + name) !== null ? name : null;\n        };\n\n        $(rowOne[0]).children('th, td').each(function (i, cell) {\n          var col = oSettings.aoColumns[i];\n\n          if (col.mData === i) {\n            var sort = a(cell, 'sort') || a(cell, 'order');\n            var filter = a(cell, 'filter') || a(cell, 'search');\n\n            if (sort !== null || filter !== null) {\n              col.mData = {\n                _: i + '.display',\n                sort: sort !== null ? i + '.@data-' + sort : undefined,\n                type: sort !== null ? i + '.@data-' + sort : undefined,\n                filter: filter !== null ? i + '.@data-' + filter : undefined\n              };\n\n              _fnColumnOptions(oSettings, i);\n            }\n          }\n        });\n      }\n\n      var features = oSettings.oFeatures;\n\n      var loadedInit = function loadedInit() {\n        /*\n         * Sorting\n         * @todo For modularisation (1.11) this needs to do into a sort start up handler\n         */\n        // If aaSorting is not defined, then we use the first indicator in asSorting\n        // in case that has been altered, so the default sort reflects that option\n        if (oInit.aaSorting === undefined) {\n          var sorting = oSettings.aaSorting;\n\n          for (i = 0, iLen = sorting.length; i < iLen; i++) {\n            sorting[i][1] = oSettings.aoColumns[i].asSorting[0];\n          }\n        }\n        /* Do a first pass on the sorting classes (allows any size changes to be taken into\n         * account, and also will apply sorting disabled classes if disabled\n         */\n\n\n        _fnSortingClasses(oSettings);\n\n        if (features.bSort) {\n          _fnCallbackReg(oSettings, 'aoDrawCallback', function () {\n            if (oSettings.bSorted) {\n              var aSort = _fnSortFlatten(oSettings);\n\n              var sortedColumns = {};\n              $.each(aSort, function (i, val) {\n                sortedColumns[val.src] = val.dir;\n              });\n\n              _fnCallbackFire(oSettings, null, 'order', [oSettings, aSort, sortedColumns]);\n\n              _fnSortAria(oSettings);\n            }\n          });\n        }\n\n        _fnCallbackReg(oSettings, 'aoDrawCallback', function () {\n          if (oSettings.bSorted || _fnDataSource(oSettings) === 'ssp' || features.bDeferRender) {\n            _fnSortingClasses(oSettings);\n          }\n        }, 'sc');\n        /*\n         * Final init\n         * Cache the header, body and footer as required, creating them if needed\n         */\n        // Work around for Webkit bug 83867 - store the caption-side before removing from doc\n\n\n        var captions = $this.children('caption').each(function () {\n          this._captionSide = $(this).css('caption-side');\n        });\n        var thead = $this.children('thead');\n\n        if (thead.length === 0) {\n          thead = $('<thead/>').appendTo($this);\n        }\n\n        oSettings.nTHead = thead[0];\n        var tbody = $this.children('tbody');\n\n        if (tbody.length === 0) {\n          tbody = $('<tbody/>').appendTo($this);\n        }\n\n        oSettings.nTBody = tbody[0];\n        var tfoot = $this.children('tfoot');\n\n        if (tfoot.length === 0 && captions.length > 0 && (oSettings.oScroll.sX !== \"\" || oSettings.oScroll.sY !== \"\")) {\n          // If we are a scrolling table, and no footer has been given, then we need to create\n          // a tfoot element for the caption element to be appended to\n          tfoot = $('<tfoot/>').appendTo($this);\n        }\n\n        if (tfoot.length === 0 || tfoot.children().length === 0) {\n          $this.addClass(oClasses.sNoFooter);\n        } else if (tfoot.length > 0) {\n          oSettings.nTFoot = tfoot[0];\n\n          _fnDetectHeader(oSettings.aoFooter, oSettings.nTFoot);\n        }\n        /* Check if there is data passing into the constructor */\n\n\n        if (oInit.aaData) {\n          for (i = 0; i < oInit.aaData.length; i++) {\n            _fnAddData(oSettings, oInit.aaData[i]);\n          }\n        } else if (oSettings.bDeferLoading || _fnDataSource(oSettings) == 'dom') {\n          /* Grab the data from the page - only do this when deferred loading or no Ajax\n           * source since there is no point in reading the DOM data if we are then going\n           * to replace it with Ajax data\n           */\n          _fnAddTr(oSettings, $(oSettings.nTBody).children('tr'));\n        }\n        /* Copy the data index array */\n\n\n        oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();\n        /* Initialisation complete - table can be drawn */\n\n        oSettings.bInitialised = true;\n        /* Check if we need to initialise the table (it might not have been handed off to the\n         * language processor)\n         */\n\n        if (bInitHandedOff === false) {\n          _fnInitialise(oSettings);\n        }\n      };\n      /* Must be done after everything which can be overridden by the state saving! */\n\n\n      if (oInit.bStateSave) {\n        features.bStateSave = true;\n\n        _fnCallbackReg(oSettings, 'aoDrawCallback', _fnSaveState, 'state_save');\n\n        _fnLoadState(oSettings, oInit, loadedInit);\n      } else {\n        loadedInit();\n      }\n    });\n    _that = null;\n    return this;\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  // Defined else where\n  //  _selector_run\n  //  _selector_opts\n  //  _selector_first\n  //  _selector_row_indexes\n\n\n  var _ext; // DataTable.ext\n\n\n  var _Api2; // DataTable.Api\n\n\n  var _api_register; // DataTable.Api.register\n\n\n  var _api_registerPlural; // DataTable.Api.registerPlural\n\n\n  var _re_dic = {};\n  var _re_new_lines = /[\\r\\n]/g;\n  var _re_html = /<.*?>/g; // This is not strict ISO8601 - Date.parse() is quite lax, although\n  // implementations differ between browsers.\n\n  var _re_date = /^\\d{2,4}[\\.\\/\\-]\\d{1,2}[\\.\\/\\-]\\d{1,2}([T ]{1}\\d{1,2}[:\\.]\\d{2}([\\.:]\\d{2})?)?$/; // Escape regular expression special characters\n\n  var _re_escape_regex = new RegExp('(\\\\' + ['/', '.', '*', '+', '?', '|', '(', ')', '[', ']', '{', '}', '\\\\', '$', '^', '-'].join('|\\\\') + ')', 'g'); // http://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.\n\n\n  var _re_formatted_numeric = /[',$£€¥%\\u2009\\u202F\\u20BD\\u20a9\\u20BArfkɃΞ]/gi;\n\n  var _empty = function _empty(d) {\n    return !d || d === true || d === '-' ? true : false;\n  };\n\n  var _intVal = function _intVal(s) {\n    var integer = parseInt(s, 10);\n    return !isNaN(integer) && isFinite(s) ? integer : null;\n  }; // Convert from a formatted number with characters other than `.` as the\n  // decimal place, to a Javascript number\n\n\n  var _numToDecimal = function _numToDecimal(num, decimalPoint) {\n    // Cache created regular expressions for speed as this function is called often\n    if (!_re_dic[decimalPoint]) {\n      _re_dic[decimalPoint] = new RegExp(_fnEscapeRegex(decimalPoint), 'g');\n    }\n\n    return typeof num === 'string' && decimalPoint !== '.' ? num.replace(/\\./g, '').replace(_re_dic[decimalPoint], '.') : num;\n  };\n\n  var _isNumber = function _isNumber(d, decimalPoint, formatted) {\n    var strType = typeof d === 'string'; // If empty return immediately so there must be a number if it is a\n    // formatted string (this stops the string \"k\", or \"kr\", etc being detected\n    // as a formatted number for currency\n\n    if (_empty(d)) {\n      return true;\n    }\n\n    if (decimalPoint && strType) {\n      d = _numToDecimal(d, decimalPoint);\n    }\n\n    if (formatted && strType) {\n      d = d.replace(_re_formatted_numeric, '');\n    }\n\n    return !isNaN(parseFloat(d)) && isFinite(d);\n  }; // A string without HTML in it can be considered to be HTML still\n\n\n  var _isHtml = function _isHtml(d) {\n    return _empty(d) || typeof d === 'string';\n  };\n\n  var _htmlNumeric = function _htmlNumeric(d, decimalPoint, formatted) {\n    if (_empty(d)) {\n      return true;\n    }\n\n    var html = _isHtml(d);\n\n    return !html ? null : _isNumber(_stripHtml(d), decimalPoint, formatted) ? true : null;\n  };\n\n  var _pluck = function _pluck(a, prop, prop2) {\n    var out = [];\n    var i = 0,\n        ien = a.length; // Could have the test in the loop for slightly smaller code, but speed\n    // is essential here\n\n    if (prop2 !== undefined) {\n      for (; i < ien; i++) {\n        if (a[i] && a[i][prop]) {\n          out.push(a[i][prop][prop2]);\n        }\n      }\n    } else {\n      for (; i < ien; i++) {\n        if (a[i]) {\n          out.push(a[i][prop]);\n        }\n      }\n    }\n\n    return out;\n  }; // Basically the same as _pluck, but rather than looping over `a` we use `order`\n  // as the indexes to pick from `a`\n\n\n  var _pluck_order = function _pluck_order(a, order, prop, prop2) {\n    var out = [];\n    var i = 0,\n        ien = order.length; // Could have the test in the loop for slightly smaller code, but speed\n    // is essential here\n\n    if (prop2 !== undefined) {\n      for (; i < ien; i++) {\n        if (a[order[i]][prop]) {\n          out.push(a[order[i]][prop][prop2]);\n        }\n      }\n    } else {\n      for (; i < ien; i++) {\n        out.push(a[order[i]][prop]);\n      }\n    }\n\n    return out;\n  };\n\n  var _range = function _range(len, start) {\n    var out = [];\n    var end;\n\n    if (start === undefined) {\n      start = 0;\n      end = len;\n    } else {\n      end = start;\n      start = len;\n    }\n\n    for (var i = start; i < end; i++) {\n      out.push(i);\n    }\n\n    return out;\n  };\n\n  var _removeEmpty = function _removeEmpty(a) {\n    var out = [];\n\n    for (var i = 0, ien = a.length; i < ien; i++) {\n      if (a[i]) {\n        // careful - will remove all falsy values!\n        out.push(a[i]);\n      }\n    }\n\n    return out;\n  };\n\n  var _stripHtml = function _stripHtml(d) {\n    return d.replace(_re_html, '');\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   */\n\n\n  var _areAllUnique = function _areAllUnique(src) {\n    if (src.length < 2) {\n      return true;\n    }\n\n    var sorted = src.slice().sort();\n    var last = sorted[0];\n\n    for (var i = 1, ien = sorted.length; i < ien; i++) {\n      if (sorted[i] === last) {\n        return false;\n      }\n\n      last = sorted[i];\n    }\n\n    return true;\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   */\n\n\n  var _unique = function _unique(src) {\n    if (_areAllUnique(src)) {\n      return src.slice();\n    } // A faster unique method is to use object keys to identify used values,\n    // but this doesn't work with arrays or objects, which we must also\n    // consider. See jsperf.com/compare-array-unique-versions/4 for more\n    // information.\n\n\n    var out = [],\n        val,\n        i,\n        ien = src.length,\n        j,\n        k = 0;\n\n    again: for (i = 0; i < ien; i++) {\n      val = src[i];\n\n      for (j = 0; j < k; j++) {\n        if (out[j] === val) {\n          continue again;\n        }\n      }\n\n      out.push(val);\n      k++;\n    }\n\n    return out;\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   */\n\n\n  DataTable.util = {\n    /**\n     * Throttle the calls to a function. Arguments and context are maintained\n     * for the throttled function.\n     *\n     * @param {function} fn Function to be called\n     * @param {integer} freq Call frequency in mS\n     * @return {function} Wrapped function\n     */\n    throttle: function throttle(fn, freq) {\n      var frequency = freq !== undefined ? freq : 200,\n          last,\n          timer;\n      return function () {\n        var that = this,\n            now = +new Date(),\n            args = arguments;\n\n        if (last && now < last + frequency) {\n          clearTimeout(timer);\n          timer = setTimeout(function () {\n            last = undefined;\n            fn.apply(that, args);\n          }, frequency);\n        } else {\n          last = now;\n          fn.apply(that, args);\n        }\n      };\n    },\n\n    /**\n     * Escape a string such that it can be used in a regular expression\n     *\n     *  @param {string} val string to escape\n     *  @returns {string} escaped string\n     */\n    escapeRegex: function escapeRegex(val) {\n      return val.replace(_re_escape_regex, '\\\\$1');\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   */\n\n  function _fnHungarianMap(o) {\n    var hungarian = 'a aa ai ao as b fn i m o s ',\n        match,\n        newKey,\n        map = {};\n    $.each(o, function (key, val) {\n      match = key.match(/^([^A-Z]+?)([A-Z])/);\n\n      if (match && hungarian.indexOf(match[1] + ' ') !== -1) {\n        newKey = key.replace(match[0], match[2].toLowerCase());\n        map[newKey] = key;\n\n        if (match[1] === 'o') {\n          _fnHungarianMap(o[key]);\n        }\n      }\n    });\n    o._hungarianMap = map;\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   */\n\n\n  function _fnCamelToHungarian(src, user, force) {\n    if (!src._hungarianMap) {\n      _fnHungarianMap(src);\n    }\n\n    var hungarianKey;\n    $.each(user, function (key, val) {\n      hungarianKey = src._hungarianMap[key];\n\n      if (hungarianKey !== undefined && (force || user[hungarianKey] === undefined)) {\n        // For objects, we need to buzz down into the object to copy parameters\n        if (hungarianKey.charAt(0) === 'o') {\n          // Copy the camelCase options over to the hungarian\n          if (!user[hungarianKey]) {\n            user[hungarianKey] = {};\n          }\n\n          $.extend(true, user[hungarianKey], user[key]);\n\n          _fnCamelToHungarian(src[hungarianKey], user[hungarianKey], force);\n        } else {\n          user[hungarianKey] = user[key];\n        }\n      }\n    });\n  }\n  /**\n   * Language compatibility - when certain options are given, and others aren't, we\n   * need to duplicate the values over, in order to provide backwards compatibility\n   * with older language files.\n   *  @param {object} oSettings dataTables settings object\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnLanguageCompat(lang) {\n    // Note the use of the Hungarian notation for the parameters in this method as\n    // this is called after the mapping of camelCase to Hungarian\n    var defaults = DataTable.defaults.oLanguage; // Default mapping\n\n    var defaultDecimal = defaults.sDecimal;\n\n    if (defaultDecimal) {\n      _addNumericSort(defaultDecimal);\n    }\n\n    if (lang) {\n      var zeroRecords = lang.sZeroRecords; // Backwards compatibility - if there is no sEmptyTable given, then use the same as\n      // sZeroRecords - assuming that is given.\n\n      if (!lang.sEmptyTable && zeroRecords && defaults.sEmptyTable === \"No data available in table\") {\n        _fnMap(lang, lang, 'sZeroRecords', 'sEmptyTable');\n      } // Likewise with loading records\n\n\n      if (!lang.sLoadingRecords && zeroRecords && defaults.sLoadingRecords === \"Loading...\") {\n        _fnMap(lang, lang, 'sZeroRecords', 'sLoadingRecords');\n      } // Old parameter name of the thousands separator mapped onto the new\n\n\n      if (lang.sInfoThousands) {\n        lang.sThousands = lang.sInfoThousands;\n      }\n\n      var decimal = lang.sDecimal;\n\n      if (decimal && defaultDecimal !== decimal) {\n        _addNumericSort(decimal);\n      }\n    }\n  }\n  /**\n   * Map one parameter onto another\n   *  @param {object} o Object to map\n   *  @param {*} knew The new parameter name\n   *  @param {*} old The old parameter name\n   */\n\n\n  var _fnCompatMap = function _fnCompatMap(o, knew, old) {\n    if (o[knew] !== undefined) {\n      o[old] = o[knew];\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   */\n\n\n  function _fnCompatOpts(init) {\n    _fnCompatMap(init, 'ordering', 'bSort');\n\n    _fnCompatMap(init, 'orderMulti', 'bSortMulti');\n\n    _fnCompatMap(init, 'orderClasses', 'bSortClasses');\n\n    _fnCompatMap(init, 'orderCellsTop', 'bSortCellsTop');\n\n    _fnCompatMap(init, 'order', 'aaSorting');\n\n    _fnCompatMap(init, 'orderFixed', 'aaSortingFixed');\n\n    _fnCompatMap(init, 'paging', 'bPaginate');\n\n    _fnCompatMap(init, 'pagingType', 'sPaginationType');\n\n    _fnCompatMap(init, 'pageLength', 'iDisplayLength');\n\n    _fnCompatMap(init, 'searching', 'bFilter'); // Boolean initialisation of x-scrolling\n\n\n    if (typeof init.sScrollX === 'boolean') {\n      init.sScrollX = init.sScrollX ? '100%' : '';\n    }\n\n    if (typeof init.scrollX === 'boolean') {\n      init.scrollX = init.scrollX ? '100%' : '';\n    } // Column search objects are in an array, so it needs to be converted\n    // element by element\n\n\n    var searchCols = init.aoSearchCols;\n\n    if (searchCols) {\n      for (var i = 0, ien = searchCols.length; i < ien; i++) {\n        if (searchCols[i]) {\n          _fnCamelToHungarian(DataTable.models.oSearch, searchCols[i]);\n        }\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   */\n\n\n  function _fnCompatCols(init) {\n    _fnCompatMap(init, 'orderable', 'bSortable');\n\n    _fnCompatMap(init, 'orderData', 'aDataSort');\n\n    _fnCompatMap(init, 'orderSequence', 'asSorting');\n\n    _fnCompatMap(init, 'orderDataType', 'sortDataType'); // orderData can be given as an integer\n\n\n    var dataSort = init.aDataSort;\n\n    if (typeof dataSort === 'number' && !$.isArray(dataSort)) {\n      init.aDataSort = [dataSort];\n    }\n  }\n  /**\n   * Browser feature detection for capabilities, quirks\n   *  @param {object} settings dataTables settings object\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnBrowserDetect(settings) {\n    // We don't need to do this every time DataTables is constructed, the values\n    // calculated are specific to the browser and OS configuration which we\n    // don't expect to change between initialisations\n    if (!DataTable.__browser) {\n      var browser = {};\n      DataTable.__browser = browser; // Scrolling feature / quirks detection\n\n      var n = $('<div/>').css({\n        position: 'fixed',\n        top: 0,\n        left: $(window).scrollLeft() * -1,\n        // allow for scrolling\n        height: 1,\n        width: 1,\n        overflow: 'hidden'\n      }).append($('<div/>').css({\n        position: 'absolute',\n        top: 1,\n        left: 1,\n        width: 100,\n        overflow: 'scroll'\n      }).append($('<div/>').css({\n        width: '100%',\n        height: 10\n      }))).appendTo('body');\n      var outer = n.children();\n      var inner = outer.children(); // Numbers below, in order, are:\n      // inner.offsetWidth, inner.clientWidth, outer.offsetWidth, outer.clientWidth\n      //\n      // IE6 XP:                           100 100 100  83\n      // IE7 Vista:                        100 100 100  83\n      // IE 8+ Windows:                     83  83 100  83\n      // Evergreen Windows:                 83  83 100  83\n      // Evergreen Mac with scrollbars:     85  85 100  85\n      // Evergreen Mac without scrollbars: 100 100 100 100\n      // Get scrollbar width\n\n      browser.barWidth = outer[0].offsetWidth - outer[0].clientWidth; // IE6/7 will oversize a width 100% element inside a scrolling element, to\n      // include the width of the scrollbar, while other browsers ensure the inner\n      // element is contained without forcing scrolling\n\n      browser.bScrollOversize = inner[0].offsetWidth === 100 && outer[0].clientWidth !== 100; // In rtl text layout, some browsers (most, but not all) will place the\n      // scrollbar on the left, rather than the right.\n\n      browser.bScrollbarLeft = Math.round(inner.offset().left) !== 1; // IE8- don't provide height and width for getBoundingClientRect\n\n      browser.bBounding = n[0].getBoundingClientRect().width ? true : false;\n      n.remove();\n    }\n\n    $.extend(settings.oBrowser, DataTable.__browser);\n    settings.oScroll.iBarWidth = DataTable.__browser.barWidth;\n  }\n  /**\n   * Array.prototype reduce[Right] method, used for browsers which don't support\n   * JS 1.6. Done this way to reduce code size, since we iterate either way\n   *  @param {object} settings dataTables settings object\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnReduce(that, fn, init, start, end, inc) {\n    var i = start,\n        value,\n        isSet = false;\n\n    if (init !== undefined) {\n      value = init;\n      isSet = true;\n    }\n\n    while (i !== end) {\n      if (!that.hasOwnProperty(i)) {\n        continue;\n      }\n\n      value = isSet ? fn(value, that[i], i, that) : that[i];\n      isSet = true;\n      i += inc;\n    }\n\n    return value;\n  }\n  /**\n   * Add a column to the list used for the table with default values\n   *  @param {object} oSettings dataTables settings object\n   *  @param {node} nTh The th element for this column\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnAddColumn(oSettings, nTh) {\n    // Add column to aoColumns array\n    var oDefaults = DataTable.defaults.column;\n    var iCol = oSettings.aoColumns.length;\n    var oCol = $.extend({}, DataTable.models.oColumn, oDefaults, {\n      \"nTh\": nTh ? nTh : document.createElement('th'),\n      \"sTitle\": oDefaults.sTitle ? oDefaults.sTitle : nTh ? nTh.innerHTML : '',\n      \"aDataSort\": oDefaults.aDataSort ? oDefaults.aDataSort : [iCol],\n      \"mData\": oDefaults.mData ? oDefaults.mData : iCol,\n      idx: iCol\n    });\n    oSettings.aoColumns.push(oCol); // Add search object for column specific search. Note that the `searchCols[ iCol ]`\n    // passed into extend can be undefined. This allows the user to give a default\n    // with only some of the parameters defined, and also not give a default\n\n    var searchCols = oSettings.aoPreSearchCols;\n    searchCols[iCol] = $.extend({}, DataTable.models.oSearch, searchCols[iCol]); // Use the default column options function to initialise classes etc\n\n    _fnColumnOptions(oSettings, iCol, $(nTh).data());\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   */\n\n\n  function _fnColumnOptions(oSettings, iCol, oOptions) {\n    var oCol = oSettings.aoColumns[iCol];\n    var oClasses = oSettings.oClasses;\n    var th = $(oCol.nTh); // Try to get width information from the DOM. We can't get it from CSS\n    // as we'd need to parse the CSS stylesheet. `width` option can override\n\n    if (!oCol.sWidthOrig) {\n      // Width attribute\n      oCol.sWidthOrig = th.attr('width') || null; // Style attribute\n\n      var t = (th.attr('style') || '').match(/width:\\s*(\\d+[pxem%]+)/);\n\n      if (t) {\n        oCol.sWidthOrig = t[1];\n      }\n    }\n    /* User specified column options */\n\n\n    if (oOptions !== undefined && oOptions !== null) {\n      // Backwards compatibility\n      _fnCompatCols(oOptions); // Map camel case parameters to their Hungarian counterparts\n\n\n      _fnCamelToHungarian(DataTable.defaults.column, oOptions);\n      /* Backwards compatibility for mDataProp */\n\n\n      if (oOptions.mDataProp !== undefined && !oOptions.mData) {\n        oOptions.mData = oOptions.mDataProp;\n      }\n\n      if (oOptions.sType) {\n        oCol._sManualType = oOptions.sType;\n      } // `class` is a reserved word in Javascript, so we need to provide\n      // the ability to use a valid name for the camel case input\n\n\n      if (oOptions.className && !oOptions.sClass) {\n        oOptions.sClass = oOptions.className;\n      }\n\n      if (oOptions.sClass) {\n        th.addClass(oOptions.sClass);\n      }\n\n      $.extend(oCol, oOptions);\n\n      _fnMap(oCol, oOptions, \"sWidth\", \"sWidthOrig\");\n      /* iDataSort to be applied (backwards compatibility), but aDataSort will take\n       * priority if defined\n       */\n\n\n      if (oOptions.iDataSort !== undefined) {\n        oCol.aDataSort = [oOptions.iDataSort];\n      }\n\n      _fnMap(oCol, oOptions, \"aDataSort\");\n    }\n    /* Cache the data get and set functions for speed */\n\n\n    var mDataSrc = oCol.mData;\n\n    var mData = _fnGetObjectDataFn(mDataSrc);\n\n    var mRender = oCol.mRender ? _fnGetObjectDataFn(oCol.mRender) : null;\n\n    var attrTest = function attrTest(src) {\n      return typeof src === 'string' && src.indexOf('@') !== -1;\n    };\n\n    oCol._bAttrSrc = $.isPlainObject(mDataSrc) && (attrTest(mDataSrc.sort) || attrTest(mDataSrc.type) || attrTest(mDataSrc.filter));\n    oCol._setter = null;\n\n    oCol.fnGetData = function (rowData, type, meta) {\n      var innerData = mData(rowData, type, undefined, meta);\n      return mRender && type ? mRender(innerData, type, rowData, meta) : innerData;\n    };\n\n    oCol.fnSetData = function (rowData, val, meta) {\n      return _fnSetObjectDataFn(mDataSrc)(rowData, val, meta);\n    }; // Indicate if DataTables should read DOM data as an object or array\n    // Used in _fnGetRowElements\n\n\n    if (typeof mDataSrc !== 'number') {\n      oSettings._rowReadObject = true;\n    }\n    /* Feature sorting overrides column specific when off */\n\n\n    if (!oSettings.oFeatures.bSort) {\n      oCol.bSortable = false;\n      th.addClass(oClasses.sSortableNone); // Have to add class here as order event isn't called\n    }\n    /* Check that the class assignment is correct for sorting */\n\n\n    var bAsc = $.inArray('asc', oCol.asSorting) !== -1;\n    var bDesc = $.inArray('desc', oCol.asSorting) !== -1;\n\n    if (!oCol.bSortable || !bAsc && !bDesc) {\n      oCol.sSortingClass = oClasses.sSortableNone;\n      oCol.sSortingClassJUI = \"\";\n    } else if (bAsc && !bDesc) {\n      oCol.sSortingClass = oClasses.sSortableAsc;\n      oCol.sSortingClassJUI = oClasses.sSortJUIAscAllowed;\n    } else if (!bAsc && bDesc) {\n      oCol.sSortingClass = oClasses.sSortableDesc;\n      oCol.sSortingClassJUI = oClasses.sSortJUIDescAllowed;\n    } else {\n      oCol.sSortingClass = oClasses.sSortable;\n      oCol.sSortingClassJUI = oClasses.sSortJUI;\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   */\n\n\n  function _fnAdjustColumnSizing(settings) {\n    /* Not interested in doing column width calculation if auto-width is disabled */\n    if (settings.oFeatures.bAutoWidth !== false) {\n      var columns = settings.aoColumns;\n\n      _fnCalculateColumnWidths(settings);\n\n      for (var i = 0, iLen = columns.length; i < iLen; i++) {\n        columns[i].nTh.style.width = columns[i].sWidth;\n      }\n    }\n\n    var scroll = settings.oScroll;\n\n    if (scroll.sY !== '' || scroll.sX !== '') {\n      _fnScrollDraw(settings);\n    }\n\n    _fnCallbackFire(settings, null, 'column-sizing', [settings]);\n  }\n  /**\n   * Covert 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   */\n\n\n  function _fnVisibleToColumnIndex(oSettings, iMatch) {\n    var aiVis = _fnGetColumns(oSettings, 'bVisible');\n\n    return typeof aiVis[iMatch] === 'number' ? aiVis[iMatch] : null;\n  }\n  /**\n   * Covert 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   */\n\n\n  function _fnColumnIndexToVisible(oSettings, iMatch) {\n    var aiVis = _fnGetColumns(oSettings, 'bVisible');\n\n    var iPos = $.inArray(iMatch, aiVis);\n    return iPos !== -1 ? iPos : null;\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   */\n\n\n  function _fnVisbleColumns(oSettings) {\n    var vis = 0; // No reduce in IE8, use a loop for now\n\n    $.each(oSettings.aoColumns, function (i, col) {\n      if (col.bVisible && $(col.nTh).css('display') !== 'none') {\n        vis++;\n      }\n    });\n    return vis;\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   */\n\n\n  function _fnGetColumns(oSettings, sParam) {\n    var a = [];\n    $.map(oSettings.aoColumns, function (val, i) {\n      if (val[sParam]) {\n        a.push(i);\n      }\n    });\n    return a;\n  }\n  /**\n   * Calculate the 'type' of a column\n   *  @param {object} settings dataTables settings object\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnColumnTypes(settings) {\n    var columns = settings.aoColumns;\n    var data = settings.aoData;\n    var types = DataTable.ext.type.detect;\n    var i, ien, j, jen, k, ken;\n    var col, cell, detectedType, cache; // For each column, spin over the \n\n    for (i = 0, ien = columns.length; i < ien; i++) {\n      col = columns[i];\n      cache = [];\n\n      if (!col.sType && col._sManualType) {\n        col.sType = col._sManualType;\n      } else if (!col.sType) {\n        for (j = 0, jen = types.length; j < jen; j++) {\n          for (k = 0, ken = data.length; k < ken; k++) {\n            // Use a cache array so we only need to get the type data\n            // from the formatter once (when using multiple detectors)\n            if (cache[k] === undefined) {\n              cache[k] = _fnGetCellData(settings, k, i, 'type');\n            }\n\n            detectedType = types[j](cache[k], settings); // If null, then this type can't apply to this column, so\n            // rather than testing all cells, break out. There is an\n            // exception for the last type which is `html`. We need to\n            // scan all rows since it is possible to mix string and HTML\n            // types\n\n            if (!detectedType && j !== types.length - 1) {\n              break;\n            } // Only a single match is needed for html type since it is\n            // bottom of the pile and very similar to string\n\n\n            if (detectedType === 'html') {\n              break;\n            }\n          } // Type is valid for all data points in the column - use this\n          // type\n\n\n          if (detectedType) {\n            col.sType = detectedType;\n            break;\n          }\n        } // Fall back - if no type was detected, always use string\n\n\n        if (!col.sType) {\n          col.sType = 'string';\n        }\n      }\n    }\n  }\n  /**\n   * Take the column definitions and static columns arrays and calculate how\n   * they relate to column indexes. The callback function will then apply the\n   * definition found for a column to a suitable configuration object.\n   *  @param {object} oSettings dataTables settings object\n   *  @param {array} aoColDefs The aoColumnDefs array that is to be applied\n   *  @param {array} aoCols The aoColumns array that defines columns individually\n   *  @param {function} fn Callback function - takes two parameters, the calculated\n   *    column index and the definition for that column.\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnApplyColumnDefs(oSettings, aoColDefs, aoCols, fn) {\n    var i, iLen, j, jLen, k, kLen, def;\n    var columns = oSettings.aoColumns; // Column definitions with aTargets\n\n    if (aoColDefs) {\n      /* Loop over the definitions array - loop in reverse so first instance has priority */\n      for (i = aoColDefs.length - 1; i >= 0; i--) {\n        def = aoColDefs[i];\n        /* Each definition can target multiple columns, as it is an array */\n\n        var aTargets = def.targets !== undefined ? def.targets : def.aTargets;\n\n        if (!$.isArray(aTargets)) {\n          aTargets = [aTargets];\n        }\n\n        for (j = 0, jLen = aTargets.length; j < jLen; j++) {\n          if (typeof aTargets[j] === 'number' && aTargets[j] >= 0) {\n            /* Add columns that we don't yet know about */\n            while (columns.length <= aTargets[j]) {\n              _fnAddColumn(oSettings);\n            }\n            /* Integer, basic index */\n\n\n            fn(aTargets[j], def);\n          } else if (typeof aTargets[j] === 'number' && aTargets[j] < 0) {\n            /* Negative integer, right to left column counting */\n            fn(columns.length + aTargets[j], def);\n          } else if (typeof aTargets[j] === 'string') {\n            /* Class name matching on TH element */\n            for (k = 0, kLen = columns.length; k < kLen; k++) {\n              if (aTargets[j] == \"_all\" || $(columns[k].nTh).hasClass(aTargets[j])) {\n                fn(k, def);\n              }\n            }\n          }\n        }\n      }\n    } // Statically defined columns array\n\n\n    if (aoCols) {\n      for (i = 0, iLen = aoCols.length; i < iLen; i++) {\n        fn(i, aoCols[i]);\n      }\n    }\n  }\n  /**\n   * Add a data array to the table, creating DOM node etc. This is the parallel to\n   * _fnGatherData, but for adding rows from a Javascript source, rather than a\n   * DOM source.\n   *  @param {object} oSettings dataTables settings object\n   *  @param {array} aData data array to be added\n   *  @param {node} [nTr] TR element to add to the table - optional. If not given,\n   *    DataTables will create a row automatically\n   *  @param {array} [anTds] Array of TD|TH elements for the row - must be given\n   *    if nTr is.\n   *  @returns {int} >=0 if successful (index of new aoData entry), -1 if failed\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnAddData(oSettings, aDataIn, nTr, anTds) {\n    /* Create the object for storing information about this new row */\n    var iRow = oSettings.aoData.length;\n    var oData = $.extend(true, {}, DataTable.models.oRow, {\n      src: nTr ? 'dom' : 'data',\n      idx: iRow\n    });\n    oData._aData = aDataIn;\n    oSettings.aoData.push(oData);\n    /* Create the cells */\n\n    var nTd, sThisType;\n    var columns = oSettings.aoColumns; // Invalidate the column types as the new data needs to be revalidated\n\n    for (var i = 0, iLen = columns.length; i < iLen; i++) {\n      columns[i].sType = null;\n    }\n    /* Add to the display array */\n\n\n    oSettings.aiDisplayMaster.push(iRow);\n    var id = oSettings.rowIdFn(aDataIn);\n\n    if (id !== undefined) {\n      oSettings.aIds[id] = oData;\n    }\n    /* Create the DOM information, or register it if already present */\n\n\n    if (nTr || !oSettings.oFeatures.bDeferRender) {\n      _fnCreateTr(oSettings, iRow, nTr, anTds);\n    }\n\n    return iRow;\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   */\n\n\n  function _fnAddTr(settings, trs) {\n    var row; // Allow an individual node to be passed in\n\n    if (!(trs instanceof $)) {\n      trs = $(trs);\n    }\n\n    return trs.map(function (i, el) {\n      row = _fnGetRowElements(settings, el);\n      return _fnAddData(settings, row.data, el, row.cells);\n    });\n  }\n  /**\n   * Take a TR element and convert it to an index in aoData\n   *  @param {object} oSettings dataTables settings object\n   *  @param {node} n the TR element to find\n   *  @returns {int} index if the node is found, null if not\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnNodeToDataIndex(oSettings, n) {\n    return n._DT_RowIndex !== undefined ? n._DT_RowIndex : null;\n  }\n  /**\n   * Take a TD element and convert it into a column data index (not the visible index)\n   *  @param {object} oSettings dataTables settings object\n   *  @param {int} iRow The row number the TD/TH can be found in\n   *  @param {node} n The TD/TH element to find\n   *  @returns {int} index if the node is found, -1 if not\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnNodeToColumnIndex(oSettings, iRow, n) {\n    return $.inArray(n, oSettings.aoData[iRow].anCells);\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' 'sort')\n   *  @returns {*} Cell data\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnGetCellData(settings, rowIdx, colIdx, type) {\n    var draw = settings.iDraw;\n    var col = settings.aoColumns[colIdx];\n    var rowData = settings.aoData[rowIdx]._aData;\n    var defaultContent = col.sDefaultContent;\n    var cellData = col.fnGetData(rowData, type, {\n      settings: settings,\n      row: rowIdx,\n      col: colIdx\n    });\n\n    if (cellData === undefined) {\n      if (settings.iDrawError != draw && defaultContent === null) {\n        _fnLog(settings, 0, \"Requested unknown parameter \" + (typeof col.mData == 'function' ? '{function}' : \"'\" + col.mData + \"'\") + \" for row \" + rowIdx + \", column \" + colIdx, 4);\n\n        settings.iDrawError = draw;\n      }\n\n      return defaultContent;\n    } // When the data source is null and a specific data type is requested (i.e.\n    // not the original data), we can use default column data\n\n\n    if ((cellData === rowData || cellData === null) && defaultContent !== null && type !== undefined) {\n      cellData = defaultContent;\n    } else if (typeof cellData === 'function') {\n      // If the data source is a function, then we run it and use the return,\n      // executing in the scope of the data object (for instances)\n      return cellData.call(rowData);\n    }\n\n    if (cellData === null && type == 'display') {\n      return '';\n    }\n\n    return cellData;\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   */\n\n\n  function _fnSetCellData(settings, rowIdx, colIdx, val) {\n    var col = settings.aoColumns[colIdx];\n    var rowData = settings.aoData[rowIdx]._aData;\n    col.fnSetData(rowData, val, {\n      settings: settings,\n      row: rowIdx,\n      col: colIdx\n    });\n  } // Private variable that is used to match action syntax in the data property object\n\n\n  var __reArray = /\\[.*?\\]$/;\n  var __reFn = /\\(\\)$/;\n  /**\n   * Split string on periods, taking into account escaped periods\n   * @param  {string} str String to split\n   * @return {array} Split string\n   */\n\n  function _fnSplitObjNotation(str) {\n    return $.map(str.match(/(\\\\.|[^\\.])+/g) || [''], function (s) {\n      return s.replace(/\\\\\\./g, '.');\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   */\n\n\n  function _fnGetObjectDataFn(mSource) {\n    if ($.isPlainObject(mSource)) {\n      /* Build an object of get functions, and wrap them in a single call */\n      var o = {};\n      $.each(mSource, function (key, val) {\n        if (val) {\n          o[key] = _fnGetObjectDataFn(val);\n        }\n      });\n      return function (data, type, row, meta) {\n        var t = o[type] || o._;\n        return t !== undefined ? t(data, type, row, meta) : data;\n      };\n    } else if (mSource === null) {\n      /* Give an empty string for rendering / sorting etc */\n      return function (data) {\n        // type, row and meta also passed, but not used\n        return data;\n      };\n    } else if (typeof mSource === 'function') {\n      return function (data, type, row, meta) {\n        return mSource(data, type, row, meta);\n      };\n    } else if (typeof mSource === 'string' && (mSource.indexOf('.') !== -1 || mSource.indexOf('[') !== -1 || mSource.indexOf('(') !== -1)) {\n      /* If there is a . in the source string then the data source is in a\n       * nested object so we loop over the data for each level to get the next\n       * level down. On each loop we test for undefined, and if found immediately\n       * return. This allows entire objects to be missing and sDefaultContent to\n       * be used if defined, rather than throwing an error\n       */\n      var fetchData = function fetchData(data, type, src) {\n        var arrayNotation, funcNotation, out, innerSrc;\n\n        if (src !== \"\") {\n          var a = _fnSplitObjNotation(src);\n\n          for (var i = 0, iLen = a.length; i < iLen; i++) {\n            // Check if we are dealing with special notation\n            arrayNotation = a[i].match(__reArray);\n            funcNotation = a[i].match(__reFn);\n\n            if (arrayNotation) {\n              // Array notation\n              a[i] = a[i].replace(__reArray, ''); // Condition allows simply [] to be passed in\n\n              if (a[i] !== \"\") {\n                data = data[a[i]];\n              }\n\n              out = []; // Get the remainder of the nested object to get\n\n              a.splice(0, i + 1);\n              innerSrc = a.join('.'); // Traverse each entry in the array getting the properties requested\n\n              if ($.isArray(data)) {\n                for (var j = 0, jLen = data.length; j < jLen; j++) {\n                  out.push(fetchData(data[j], type, innerSrc));\n                }\n              } // If a string is given in between the array notation indicators, that\n              // is used to join the strings together, otherwise an array is returned\n\n\n              var join = arrayNotation[0].substring(1, arrayNotation[0].length - 1);\n              data = join === \"\" ? out : out.join(join); // The inner call to fetchData has already traversed through the remainder\n              // of the source requested, so we exit from the loop\n\n              break;\n            } else if (funcNotation) {\n              // Function call\n              a[i] = a[i].replace(__reFn, '');\n              data = data[a[i]]();\n              continue;\n            }\n\n            if (data === null || data[a[i]] === undefined) {\n              return undefined;\n            }\n\n            data = data[a[i]];\n          }\n        }\n\n        return data;\n      };\n\n      return function (data, type) {\n        // row and meta also passed, but not used\n        return fetchData(data, type, mSource);\n      };\n    } else {\n      /* Array or flat object mapping */\n      return function (data, type) {\n        // row and meta also passed, but not used\n        return data[mSource];\n      };\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   */\n\n\n  function _fnSetObjectDataFn(mSource) {\n    if ($.isPlainObject(mSource)) {\n      /* Unlike get, only the underscore (global) option is used for for\n       * setting data since we don't know the type here. This is why an object\n       * option is not documented for `mData` (which is read/write), but it is\n       * for `mRender` which is read only.\n       */\n      return _fnSetObjectDataFn(mSource._);\n    } else if (mSource === null) {\n      /* Nothing to do when the data source is null */\n      return function () {};\n    } else if (typeof mSource === 'function') {\n      return function (data, val, meta) {\n        mSource(data, 'set', val, meta);\n      };\n    } else if (typeof mSource === 'string' && (mSource.indexOf('.') !== -1 || mSource.indexOf('[') !== -1 || mSource.indexOf('(') !== -1)) {\n      /* Like the get, we need to get data from a nested object */\n      var setData = function setData(data, val, src) {\n        var a = _fnSplitObjNotation(src),\n            b;\n\n        var aLast = a[a.length - 1];\n        var arrayNotation, funcNotation, o, innerSrc;\n\n        for (var i = 0, iLen = a.length - 1; i < iLen; i++) {\n          // Check if we are dealing with an array notation request\n          arrayNotation = a[i].match(__reArray);\n          funcNotation = a[i].match(__reFn);\n\n          if (arrayNotation) {\n            a[i] = a[i].replace(__reArray, '');\n            data[a[i]] = []; // Get the remainder of the nested object to set so we can recurse\n\n            b = a.slice();\n            b.splice(0, i + 1);\n            innerSrc = b.join('.'); // Traverse each entry in the array setting the properties requested\n\n            if ($.isArray(val)) {\n              for (var j = 0, jLen = val.length; j < jLen; j++) {\n                o = {};\n                setData(o, val[j], innerSrc);\n                data[a[i]].push(o);\n              }\n            } else {\n              // We've been asked to save data to an array, but it\n              // isn't array data to be saved. Best that can be done\n              // is to just save the value.\n              data[a[i]] = val;\n            } // The inner call to setData has already traversed through the remainder\n            // of the source and has set the data, thus we can exit here\n\n\n            return;\n          } else if (funcNotation) {\n            // Function call\n            a[i] = a[i].replace(__reFn, '');\n            data = data[a[i]](val);\n          } // If the nested object doesn't currently exist - since we are\n          // trying to set the value - create it\n\n\n          if (data[a[i]] === null || data[a[i]] === undefined) {\n            data[a[i]] = {};\n          }\n\n          data = data[a[i]];\n        } // Last item in the input - i.e, the actual set\n\n\n        if (aLast.match(__reFn)) {\n          // Function call\n          data = data[aLast.replace(__reFn, '')](val);\n        } else {\n          // If array notation is used, we just want to strip it and use the property name\n          // and assign the value. If it isn't used, then we get the result we want anyway\n          data[aLast.replace(__reArray, '')] = val;\n        }\n      };\n\n      return function (data, val) {\n        // meta is also passed in, but not used\n        return setData(data, val, mSource);\n      };\n    } else {\n      /* Array or flat object mapping */\n      return function (data, val) {\n        // meta is also passed in, but not used\n        data[mSource] = val;\n      };\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   */\n\n\n  function _fnGetDataMaster(settings) {\n    return _pluck(settings.aoData, '_aData');\n  }\n  /**\n   * Nuke the table\n   *  @param {object} oSettings dataTables settings object\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnClearTable(settings) {\n    settings.aoData.length = 0;\n    settings.aiDisplayMaster.length = 0;\n    settings.aiDisplay.length = 0;\n    settings.aIds = {};\n  }\n  /**\n  * Take an array of integers (index array) and remove a target integer (value - not\n  * the key!)\n  *  @param {array} a Index array to target\n  *  @param {int} iTarget value to find\n  *  @memberof DataTable#oApi\n  */\n\n\n  function _fnDeleteIndex(a, iTarget, splice) {\n    var iTargetIndex = -1;\n\n    for (var i = 0, iLen = a.length; i < iLen; i++) {\n      if (a[i] == iTarget) {\n        iTargetIndex = i;\n      } else if (a[i] > iTarget) {\n        a[i]--;\n      }\n    }\n\n    if (iTargetIndex != -1 && splice === undefined) {\n      a.splice(iTargetIndex, 1);\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   */\n\n\n  function _fnInvalidate(settings, rowIdx, src, colIdx) {\n    var row = settings.aoData[rowIdx];\n    var i, ien;\n\n    var cellWrite = function cellWrite(cell, col) {\n      // This is very frustrating, but in IE if you just write directly\n      // to innerHTML, and elements that are overwritten are GC'ed,\n      // even if there is a reference to them elsewhere\n      while (cell.childNodes.length) {\n        cell.removeChild(cell.firstChild);\n      }\n\n      cell.innerHTML = _fnGetCellData(settings, rowIdx, col, 'display');\n    }; // Are we reading last data from DOM or the data object?\n\n\n    if (src === 'dom' || (!src || src === 'auto') && row.src === 'dom') {\n      // Read the data from the DOM\n      row._aData = _fnGetRowElements(settings, row, colIdx, colIdx === undefined ? undefined : row._aData).data;\n    } else {\n      // Reading from data object, update the DOM\n      var cells = row.anCells;\n\n      if (cells) {\n        if (colIdx !== undefined) {\n          cellWrite(cells[colIdx], colIdx);\n        } else {\n          for (i = 0, ien = cells.length; i < ien; i++) {\n            cellWrite(cells[i], i);\n          }\n        }\n      }\n    } // For both row and cell invalidation, the cached data for sorting and\n    // filtering is nulled out\n\n\n    row._aSortData = null;\n    row._aFilterData = null; // Invalidate the type for a specific column (if given) or all columns since\n    // the data might have changed\n\n    var cols = settings.aoColumns;\n\n    if (colIdx !== undefined) {\n      cols[colIdx].sType = null;\n    } else {\n      for (i = 0, ien = cols.length; i < ien; i++) {\n        cols[i].sType = null;\n      } // Update DataTables special `DT_*` attributes for the row\n\n\n      _fnRowAttributes(settings, row);\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   */\n\n\n  function _fnGetRowElements(settings, row, colIdx, d) {\n    var tds = [],\n        td = row.firstChild,\n        name,\n        col,\n        o,\n        i = 0,\n        contents,\n        columns = settings.aoColumns,\n        objectRead = settings._rowReadObject; // Allow the data object to be passed in, or construct\n\n    d = d !== undefined ? d : objectRead ? {} : [];\n\n    var attr = function attr(str, td) {\n      if (typeof str === 'string') {\n        var idx = str.indexOf('@');\n\n        if (idx !== -1) {\n          var attr = str.substring(idx + 1);\n\n          var setter = _fnSetObjectDataFn(str);\n\n          setter(d, td.getAttribute(attr));\n        }\n      }\n    }; // Read data from a cell and store into the data object\n\n\n    var cellProcess = function cellProcess(cell) {\n      if (colIdx === undefined || colIdx === i) {\n        col = columns[i];\n        contents = $.trim(cell.innerHTML);\n\n        if (col && col._bAttrSrc) {\n          var setter = _fnSetObjectDataFn(col.mData._);\n\n          setter(d, contents);\n          attr(col.mData.sort, cell);\n          attr(col.mData.type, cell);\n          attr(col.mData.filter, cell);\n        } else {\n          // Depending on the `data` option for the columns the data can\n          // be read to either an object or an array.\n          if (objectRead) {\n            if (!col._setter) {\n              // Cache the setter function\n              col._setter = _fnSetObjectDataFn(col.mData);\n            }\n\n            col._setter(d, contents);\n          } else {\n            d[i] = contents;\n          }\n        }\n      }\n\n      i++;\n    };\n\n    if (td) {\n      // `tr` element was passed in\n      while (td) {\n        name = td.nodeName.toUpperCase();\n\n        if (name == \"TD\" || name == \"TH\") {\n          cellProcess(td);\n          tds.push(td);\n        }\n\n        td = td.nextSibling;\n      }\n    } else {\n      // Existing row object passed in\n      tds = row.anCells;\n\n      for (var j = 0, jen = tds.length; j < jen; j++) {\n        cellProcess(tds[j]);\n      }\n    } // Read the ID from the DOM if present\n\n\n    var rowNode = row.firstChild ? row : row.nTr;\n\n    if (rowNode) {\n      var id = rowNode.getAttribute('id');\n\n      if (id) {\n        _fnSetObjectDataFn(settings.rowId)(d, id);\n      }\n    }\n\n    return {\n      data: d,\n      cells: tds\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   */\n\n\n  function _fnCreateTr(oSettings, iRow, nTrIn, anTds) {\n    var row = oSettings.aoData[iRow],\n        rowData = row._aData,\n        cells = [],\n        nTr,\n        nTd,\n        oCol,\n        i,\n        iLen;\n\n    if (row.nTr === null) {\n      nTr = nTrIn || document.createElement('tr');\n      row.nTr = nTr;\n      row.anCells = cells;\n      /* Use a private property on the node to allow reserve mapping from the node\n       * to the aoData array for fast look up\n       */\n\n      nTr._DT_RowIndex = iRow;\n      /* Special parameters can be given by the data source to be used on the row */\n\n      _fnRowAttributes(oSettings, row);\n      /* Process each column */\n\n\n      for (i = 0, iLen = oSettings.aoColumns.length; i < iLen; i++) {\n        oCol = oSettings.aoColumns[i];\n        nTd = nTrIn ? anTds[i] : document.createElement(oCol.sCellType);\n        nTd._DT_CellIndex = {\n          row: iRow,\n          column: i\n        };\n        cells.push(nTd); // Need to create the HTML if new, or if a rendering function is defined\n\n        if ((!nTrIn || oCol.mRender || oCol.mData !== i) && (!$.isPlainObject(oCol.mData) || oCol.mData._ !== i + '.display')) {\n          nTd.innerHTML = _fnGetCellData(oSettings, iRow, i, 'display');\n        }\n        /* Add user defined class */\n\n\n        if (oCol.sClass) {\n          nTd.className += ' ' + oCol.sClass;\n        } // Visibility - add or remove as required\n\n\n        if (oCol.bVisible && !nTrIn) {\n          nTr.appendChild(nTd);\n        } else if (!oCol.bVisible && nTrIn) {\n          nTd.parentNode.removeChild(nTd);\n        }\n\n        if (oCol.fnCreatedCell) {\n          oCol.fnCreatedCell.call(oSettings.oInstance, nTd, _fnGetCellData(oSettings, iRow, i), rowData, iRow, i);\n        }\n      }\n\n      _fnCallbackFire(oSettings, 'aoRowCreatedCallback', null, [nTr, rowData, iRow, cells]);\n    } // Remove once webkit bug 131819 and Chromium bug 365619 have been resolved\n    // and deployed\n\n\n    row.nTr.setAttribute('role', 'row');\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   */\n\n\n  function _fnRowAttributes(settings, row) {\n    var tr = row.nTr;\n    var data = row._aData;\n\n    if (tr) {\n      var id = settings.rowIdFn(data);\n\n      if (id) {\n        tr.id = id;\n      }\n\n      if (data.DT_RowClass) {\n        // Remove any classes added by DT_RowClass before\n        var a = data.DT_RowClass.split(' ');\n        row.__rowc = row.__rowc ? _unique(row.__rowc.concat(a)) : a;\n        $(tr).removeClass(row.__rowc.join(' ')).addClass(data.DT_RowClass);\n      }\n\n      if (data.DT_RowAttr) {\n        $(tr).attr(data.DT_RowAttr);\n      }\n\n      if (data.DT_RowData) {\n        $(tr).data(data.DT_RowData);\n      }\n    }\n  }\n  /**\n   * Create the HTML header for the table\n   *  @param {object} oSettings dataTables settings object\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnBuildHead(oSettings) {\n    var i, ien, cell, row, column;\n    var thead = oSettings.nTHead;\n    var tfoot = oSettings.nTFoot;\n    var createHeader = $('th, td', thead).length === 0;\n    var classes = oSettings.oClasses;\n    var columns = oSettings.aoColumns;\n\n    if (createHeader) {\n      row = $('<tr/>').appendTo(thead);\n    }\n\n    for (i = 0, ien = columns.length; i < ien; i++) {\n      column = columns[i];\n      cell = $(column.nTh).addClass(column.sClass);\n\n      if (createHeader) {\n        cell.appendTo(row);\n      } // 1.11 move into sorting\n\n\n      if (oSettings.oFeatures.bSort) {\n        cell.addClass(column.sSortingClass);\n\n        if (column.bSortable !== false) {\n          cell.attr('tabindex', oSettings.iTabIndex).attr('aria-controls', oSettings.sTableId);\n\n          _fnSortAttachListener(oSettings, column.nTh, i);\n        }\n      }\n\n      if (column.sTitle != cell[0].innerHTML) {\n        cell.html(column.sTitle);\n      }\n\n      _fnRenderer(oSettings, 'header')(oSettings, cell, column, classes);\n    }\n\n    if (createHeader) {\n      _fnDetectHeader(oSettings.aoHeader, thead);\n    }\n    /* ARIA role for the rows */\n\n\n    $(thead).find('>tr').attr('role', 'row');\n    /* Deal with the footer - add classes if required */\n\n    $(thead).find('>tr>th, >tr>td').addClass(classes.sHeaderTH);\n    $(tfoot).find('>tr>th, >tr>td').addClass(classes.sFooterTH); // Cache the footer cells. Note that we only take the cells from the first\n    // row in the footer. If there is more than one row the user wants to\n    // interact with, they need to use the table().foot() method. Note also this\n    // allows cells to be used for multiple columns using colspan\n\n    if (tfoot !== null) {\n      var cells = oSettings.aoFooter[0];\n\n      for (i = 0, ien = cells.length; i < ien; i++) {\n        column = columns[i];\n        column.nTf = cells[i].cell;\n\n        if (column.sClass) {\n          $(column.nTf).addClass(column.sClass);\n        }\n      }\n    }\n  }\n  /**\n   * Draw the header (or footer) element based on the column visibility states. The\n   * methodology here is to use the layout array from _fnDetectHeader, modified for\n   * the instantaneous column visibility, to construct the new layout. The grid is\n   * traversed over cell at a time in a rows x columns grid fashion, although each\n   * cell insert can cover multiple elements in the grid - which is tracks using the\n   * aApplied array. Cell inserts in the grid will only occur where there isn't\n   * already a cell in that position.\n   *  @param {object} oSettings dataTables settings object\n   *  @param array {objects} aoSource Layout array from _fnDetectHeader\n   *  @param {boolean} [bIncludeHidden=false] If true then include the hidden columns in the calc,\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnDrawHead(oSettings, aoSource, bIncludeHidden) {\n    var i, iLen, j, jLen, k, kLen, n, nLocalTr;\n    var aoLocal = [];\n    var aApplied = [];\n    var iColumns = oSettings.aoColumns.length;\n    var iRowspan, iColspan;\n\n    if (!aoSource) {\n      return;\n    }\n\n    if (bIncludeHidden === undefined) {\n      bIncludeHidden = false;\n    }\n    /* Make a copy of the master layout array, but without the visible columns in it */\n\n\n    for (i = 0, iLen = aoSource.length; i < iLen; i++) {\n      aoLocal[i] = aoSource[i].slice();\n      aoLocal[i].nTr = aoSource[i].nTr;\n      /* Remove any columns which are currently hidden */\n\n      for (j = iColumns - 1; j >= 0; j--) {\n        if (!oSettings.aoColumns[j].bVisible && !bIncludeHidden) {\n          aoLocal[i].splice(j, 1);\n        }\n      }\n      /* Prep the applied array - it needs an element for each row */\n\n\n      aApplied.push([]);\n    }\n\n    for (i = 0, iLen = aoLocal.length; i < iLen; i++) {\n      nLocalTr = aoLocal[i].nTr;\n      /* All cells are going to be replaced, so empty out the row */\n\n      if (nLocalTr) {\n        while (n = nLocalTr.firstChild) {\n          nLocalTr.removeChild(n);\n        }\n      }\n\n      for (j = 0, jLen = aoLocal[i].length; j < jLen; j++) {\n        iRowspan = 1;\n        iColspan = 1;\n        /* Check to see if there is already a cell (row/colspan) covering our target\n         * insert point. If there is, then there is nothing to do.\n         */\n\n        if (aApplied[i][j] === undefined) {\n          nLocalTr.appendChild(aoLocal[i][j].cell);\n          aApplied[i][j] = 1;\n          /* Expand the cell to cover as many rows as needed */\n\n          while (aoLocal[i + iRowspan] !== undefined && aoLocal[i][j].cell == aoLocal[i + iRowspan][j].cell) {\n            aApplied[i + iRowspan][j] = 1;\n            iRowspan++;\n          }\n          /* Expand the cell to cover as many columns as needed */\n\n\n          while (aoLocal[i][j + iColspan] !== undefined && aoLocal[i][j].cell == aoLocal[i][j + iColspan].cell) {\n            /* Must update the applied array over the rows for the columns */\n            for (k = 0; k < iRowspan; k++) {\n              aApplied[i + k][j + iColspan] = 1;\n            }\n\n            iColspan++;\n          }\n          /* Do the actual expansion in the DOM */\n\n\n          $(aoLocal[i][j].cell).attr('rowspan', iRowspan).attr('colspan', iColspan);\n        }\n      }\n    }\n  }\n  /**\n   * Insert the required TR nodes into the table for display\n   *  @param {object} oSettings dataTables settings object\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnDraw(oSettings) {\n    /* Provide a pre-callback function which can be used to cancel the draw is false is returned */\n    var aPreDraw = _fnCallbackFire(oSettings, 'aoPreDrawCallback', 'preDraw', [oSettings]);\n\n    if ($.inArray(false, aPreDraw) !== -1) {\n      _fnProcessingDisplay(oSettings, false);\n\n      return;\n    }\n\n    var i, iLen, n;\n    var anRows = [];\n    var iRowCount = 0;\n    var asStripeClasses = oSettings.asStripeClasses;\n    var iStripes = asStripeClasses.length;\n    var iOpenRows = oSettings.aoOpenRows.length;\n    var oLang = oSettings.oLanguage;\n    var iInitDisplayStart = oSettings.iInitDisplayStart;\n    var bServerSide = _fnDataSource(oSettings) == 'ssp';\n    var aiDisplay = oSettings.aiDisplay;\n    oSettings.bDrawing = true;\n    /* Check and see if we have an initial draw position from state saving */\n\n    if (iInitDisplayStart !== undefined && iInitDisplayStart !== -1) {\n      oSettings._iDisplayStart = bServerSide ? iInitDisplayStart : iInitDisplayStart >= oSettings.fnRecordsDisplay() ? 0 : iInitDisplayStart;\n      oSettings.iInitDisplayStart = -1;\n    }\n\n    var iDisplayStart = oSettings._iDisplayStart;\n    var iDisplayEnd = oSettings.fnDisplayEnd();\n    /* Server-side processing draw intercept */\n\n    if (oSettings.bDeferLoading) {\n      oSettings.bDeferLoading = false;\n      oSettings.iDraw++;\n\n      _fnProcessingDisplay(oSettings, false);\n    } else if (!bServerSide) {\n      oSettings.iDraw++;\n    } else if (!oSettings.bDestroying && !_fnAjaxUpdate(oSettings)) {\n      return;\n    }\n\n    if (aiDisplay.length !== 0) {\n      var iStart = bServerSide ? 0 : iDisplayStart;\n      var iEnd = bServerSide ? oSettings.aoData.length : iDisplayEnd;\n\n      for (var j = iStart; j < iEnd; j++) {\n        var iDataIndex = aiDisplay[j];\n        var aoData = oSettings.aoData[iDataIndex];\n\n        if (aoData.nTr === null) {\n          _fnCreateTr(oSettings, iDataIndex);\n        }\n\n        var nRow = aoData.nTr;\n        /* Remove the old striping classes and then add the new one */\n\n        if (iStripes !== 0) {\n          var sStripe = asStripeClasses[iRowCount % iStripes];\n\n          if (aoData._sRowStripe != sStripe) {\n            $(nRow).removeClass(aoData._sRowStripe).addClass(sStripe);\n            aoData._sRowStripe = sStripe;\n          }\n        } // Row callback functions - might want to manipulate the row\n        // iRowCount and j are not currently documented. Are they at all\n        // useful?\n\n\n        _fnCallbackFire(oSettings, 'aoRowCallback', null, [nRow, aoData._aData, iRowCount, j, iDataIndex]);\n\n        anRows.push(nRow);\n        iRowCount++;\n      }\n    } else {\n      /* Table is empty - create a row with an empty message in it */\n      var sZero = oLang.sZeroRecords;\n\n      if (oSettings.iDraw == 1 && _fnDataSource(oSettings) == 'ajax') {\n        sZero = oLang.sLoadingRecords;\n      } else if (oLang.sEmptyTable && oSettings.fnRecordsTotal() === 0) {\n        sZero = oLang.sEmptyTable;\n      }\n\n      anRows[0] = $('<tr/>', {\n        'class': iStripes ? asStripeClasses[0] : ''\n      }).append($('<td />', {\n        'valign': 'top',\n        'colSpan': _fnVisbleColumns(oSettings),\n        'class': oSettings.oClasses.sRowEmpty\n      }).html(sZero))[0];\n    }\n    /* Header and footer callbacks */\n\n\n    _fnCallbackFire(oSettings, 'aoHeaderCallback', 'header', [$(oSettings.nTHead).children('tr')[0], _fnGetDataMaster(oSettings), iDisplayStart, iDisplayEnd, aiDisplay]);\n\n    _fnCallbackFire(oSettings, 'aoFooterCallback', 'footer', [$(oSettings.nTFoot).children('tr')[0], _fnGetDataMaster(oSettings), iDisplayStart, iDisplayEnd, aiDisplay]);\n\n    var body = $(oSettings.nTBody);\n    body.children().detach();\n    body.append($(anRows));\n    /* Call all required callback functions for the end of a draw */\n\n    _fnCallbackFire(oSettings, 'aoDrawCallback', 'draw', [oSettings]);\n    /* Draw is complete, sorting and filtering must be as well */\n\n\n    oSettings.bSorted = false;\n    oSettings.bFiltered = false;\n    oSettings.bDrawing = false;\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   */\n\n\n  function _fnReDraw(settings, holdPosition) {\n    var features = settings.oFeatures,\n        sort = features.bSort,\n        filter = features.bFilter;\n\n    if (sort) {\n      _fnSort(settings);\n    }\n\n    if (filter) {\n      _fnFilterComplete(settings, settings.oPreviousSearch);\n    } else {\n      // No filtering, so we want to just use the display master\n      settings.aiDisplay = settings.aiDisplayMaster.slice();\n    }\n\n    if (holdPosition !== true) {\n      settings._iDisplayStart = 0;\n    } // Let any modules know about the draw hold position state (used by\n    // scrolling internally)\n\n\n    settings._drawHold = holdPosition;\n\n    _fnDraw(settings);\n\n    settings._drawHold = false;\n  }\n  /**\n   * Add the options to the page HTML for the table\n   *  @param {object} oSettings dataTables settings object\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnAddOptionsHtml(oSettings) {\n    var classes = oSettings.oClasses;\n    var table = $(oSettings.nTable);\n    var holding = $('<div/>').insertBefore(table); // Holding element for speed\n\n    var features = oSettings.oFeatures; // All DataTables are wrapped in a div\n\n    var insert = $('<div/>', {\n      id: oSettings.sTableId + '_wrapper',\n      'class': classes.sWrapper + (oSettings.nTFoot ? '' : ' ' + classes.sNoFooter)\n    });\n    oSettings.nHolding = holding[0];\n    oSettings.nTableWrapper = insert[0];\n    oSettings.nTableReinsertBefore = oSettings.nTable.nextSibling;\n    /* Loop over the user set positioning and place the elements as needed */\n\n    var aDom = oSettings.sDom.split('');\n    var featureNode, cOption, nNewNode, cNext, sAttr, j;\n\n    for (var i = 0; i < aDom.length; i++) {\n      featureNode = null;\n      cOption = aDom[i];\n\n      if (cOption == '<') {\n        /* New container div */\n        nNewNode = $('<div/>')[0];\n        /* Check to see if we should append an id and/or a class name to the container */\n\n        cNext = aDom[i + 1];\n\n        if (cNext == \"'\" || cNext == '\"') {\n          sAttr = \"\";\n          j = 2;\n\n          while (aDom[i + j] != cNext) {\n            sAttr += aDom[i + j];\n            j++;\n          }\n          /* Replace jQuery UI constants @todo depreciated */\n\n\n          if (sAttr == \"H\") {\n            sAttr = classes.sJUIHeader;\n          } else if (sAttr == \"F\") {\n            sAttr = classes.sJUIFooter;\n          }\n          /* The attribute can be in the format of \"#id.class\", \"#id\" or \"class\" This logic\n           * breaks the string into parts and applies them as needed\n           */\n\n\n          if (sAttr.indexOf('.') != -1) {\n            var aSplit = sAttr.split('.');\n            nNewNode.id = aSplit[0].substr(1, aSplit[0].length - 1);\n            nNewNode.className = aSplit[1];\n          } else if (sAttr.charAt(0) == \"#\") {\n            nNewNode.id = sAttr.substr(1, sAttr.length - 1);\n          } else {\n            nNewNode.className = sAttr;\n          }\n\n          i += j;\n          /* Move along the position array */\n        }\n\n        insert.append(nNewNode);\n        insert = $(nNewNode);\n      } else if (cOption == '>') {\n        /* End container div */\n        insert = insert.parent();\n      } // @todo Move options into their own plugins?\n      else if (cOption == 'l' && features.bPaginate && features.bLengthChange) {\n          /* Length */\n          featureNode = _fnFeatureHtmlLength(oSettings);\n        } else if (cOption == 'f' && features.bFilter) {\n          /* Filter */\n          featureNode = _fnFeatureHtmlFilter(oSettings);\n        } else if (cOption == 'r' && features.bProcessing) {\n          /* pRocessing */\n          featureNode = _fnFeatureHtmlProcessing(oSettings);\n        } else if (cOption == 't') {\n          /* Table */\n          featureNode = _fnFeatureHtmlTable(oSettings);\n        } else if (cOption == 'i' && features.bInfo) {\n          /* Info */\n          featureNode = _fnFeatureHtmlInfo(oSettings);\n        } else if (cOption == 'p' && features.bPaginate) {\n          /* Pagination */\n          featureNode = _fnFeatureHtmlPaginate(oSettings);\n        } else if (DataTable.ext.feature.length !== 0) {\n          /* Plug-in features */\n          var aoFeatures = DataTable.ext.feature;\n\n          for (var k = 0, kLen = aoFeatures.length; k < kLen; k++) {\n            if (cOption == aoFeatures[k].cFeature) {\n              featureNode = aoFeatures[k].fnInit(oSettings);\n              break;\n            }\n          }\n        }\n      /* Add to the 2D features array */\n\n\n      if (featureNode) {\n        var aanFeatures = oSettings.aanFeatures;\n\n        if (!aanFeatures[cOption]) {\n          aanFeatures[cOption] = [];\n        }\n\n        aanFeatures[cOption].push(featureNode);\n        insert.append(featureNode);\n      }\n    }\n    /* Built our DOM structure - replace the holding div with what we want */\n\n\n    holding.replaceWith(insert);\n    oSettings.nHolding = null;\n  }\n  /**\n   * Use the DOM source to create up an array of header cells. The idea here is to\n   * create a layout grid (array) of rows x columns, which contains a reference\n   * to the cell that that point in the grid (regardless of col/rowspan), such that\n   * any column / row could be removed and the new grid constructed\n   *  @param array {object} aLayout Array to store the calculated layout in\n   *  @param {node} nThead The header/footer element for the table\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnDetectHeader(aLayout, nThead) {\n    var nTrs = $(nThead).children('tr');\n    var nTr, nCell;\n    var i, k, l, iLen, jLen, iColShifted, iColumn, iColspan, iRowspan;\n    var bUnique;\n\n    var fnShiftCol = function fnShiftCol(a, i, j) {\n      var k = a[i];\n\n      while (k[j]) {\n        j++;\n      }\n\n      return j;\n    };\n\n    aLayout.splice(0, aLayout.length);\n    /* We know how many rows there are in the layout - so prep it */\n\n    for (i = 0, iLen = nTrs.length; i < iLen; i++) {\n      aLayout.push([]);\n    }\n    /* Calculate a layout array */\n\n\n    for (i = 0, iLen = nTrs.length; i < iLen; i++) {\n      nTr = nTrs[i];\n      iColumn = 0;\n      /* For every cell in the row... */\n\n      nCell = nTr.firstChild;\n\n      while (nCell) {\n        if (nCell.nodeName.toUpperCase() == \"TD\" || nCell.nodeName.toUpperCase() == \"TH\") {\n          /* Get the col and rowspan attributes from the DOM and sanitise them */\n          iColspan = nCell.getAttribute('colspan') * 1;\n          iRowspan = nCell.getAttribute('rowspan') * 1;\n          iColspan = !iColspan || iColspan === 0 || iColspan === 1 ? 1 : iColspan;\n          iRowspan = !iRowspan || iRowspan === 0 || iRowspan === 1 ? 1 : iRowspan;\n          /* There might be colspan cells already in this row, so shift our target\n           * accordingly\n           */\n\n          iColShifted = fnShiftCol(aLayout, i, iColumn);\n          /* Cache calculation for unique columns */\n\n          bUnique = iColspan === 1 ? true : false;\n          /* If there is col / rowspan, copy the information into the layout grid */\n\n          for (l = 0; l < iColspan; l++) {\n            for (k = 0; k < iRowspan; k++) {\n              aLayout[i + k][iColShifted + l] = {\n                \"cell\": nCell,\n                \"unique\": bUnique\n              };\n              aLayout[i + k].nTr = nTr;\n            }\n          }\n        }\n\n        nCell = nCell.nextSibling;\n      }\n    }\n  }\n  /**\n   * Get an array of unique th elements, one for each column\n   *  @param {object} oSettings dataTables settings object\n   *  @param {node} nHeader automatically detect the layout from this node - optional\n   *  @param {array} aLayout thead/tfoot layout from _fnDetectHeader - optional\n   *  @returns array {node} aReturn list of unique th's\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnGetUniqueThs(oSettings, nHeader, aLayout) {\n    var aReturn = [];\n\n    if (!aLayout) {\n      aLayout = oSettings.aoHeader;\n\n      if (nHeader) {\n        aLayout = [];\n\n        _fnDetectHeader(aLayout, nHeader);\n      }\n    }\n\n    for (var i = 0, iLen = aLayout.length; i < iLen; i++) {\n      for (var j = 0, jLen = aLayout[i].length; j < jLen; j++) {\n        if (aLayout[i][j].unique && (!aReturn[j] || !oSettings.bSortCellsTop)) {\n          aReturn[j] = aLayout[i][j].cell;\n        }\n      }\n    }\n\n    return aReturn;\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   */\n\n\n  function _fnBuildAjax(oSettings, data, fn) {\n    // Compatibility with 1.9-, allow fnServerData and event to manipulate\n    _fnCallbackFire(oSettings, 'aoServerParams', 'serverParams', [data]); // Convert to object based for 1.10+ if using the old array scheme which can\n    // come from server-side processing or serverParams\n\n\n    if (data && $.isArray(data)) {\n      var tmp = {};\n      var rbracket = /(.*?)\\[\\]$/;\n      $.each(data, function (key, val) {\n        var match = val.name.match(rbracket);\n\n        if (match) {\n          // Support for arrays\n          var name = match[0];\n\n          if (!tmp[name]) {\n            tmp[name] = [];\n          }\n\n          tmp[name].push(val.value);\n        } else {\n          tmp[val.name] = val.value;\n        }\n      });\n      data = tmp;\n    }\n\n    var ajaxData;\n    var ajax = oSettings.ajax;\n    var instance = oSettings.oInstance;\n\n    var callback = function callback(json) {\n      _fnCallbackFire(oSettings, null, 'xhr', [oSettings, json, oSettings.jqXHR]);\n\n      fn(json);\n    };\n\n    if ($.isPlainObject(ajax) && ajax.data) {\n      ajaxData = ajax.data;\n      var newData = typeof ajaxData === 'function' ? ajaxData(data, oSettings) : // fn can manipulate data or return\n      ajaxData; // an object object or array to merge\n      // If the function returned something, use that alone\n\n      data = typeof ajaxData === 'function' && newData ? newData : $.extend(true, data, newData); // Remove the data property as we've resolved it already and don't want\n      // jQuery to do it again (it is restored at the end of the function)\n\n      delete ajax.data;\n    }\n\n    var baseAjax = {\n      \"data\": data,\n      \"success\": function success(json) {\n        var error = json.error || json.sError;\n\n        if (error) {\n          _fnLog(oSettings, 0, error);\n        }\n\n        oSettings.json = json;\n        callback(json);\n      },\n      \"dataType\": \"json\",\n      \"cache\": false,\n      \"type\": oSettings.sServerMethod,\n      \"error\": function error(xhr, _error, thrown) {\n        var ret = _fnCallbackFire(oSettings, null, 'xhr', [oSettings, null, oSettings.jqXHR]);\n\n        if ($.inArray(true, ret) === -1) {\n          if (_error == \"parsererror\") {\n            _fnLog(oSettings, 0, 'Invalid JSON response', 1);\n          } else if (xhr.readyState === 4) {\n            _fnLog(oSettings, 0, 'Ajax error', 7);\n          }\n        }\n\n        _fnProcessingDisplay(oSettings, false);\n      }\n    }; // Store the data submitted for the API\n\n    oSettings.oAjaxData = data; // Allow plug-ins and external processes to modify the data\n\n    _fnCallbackFire(oSettings, null, 'preXhr', [oSettings, data]);\n\n    if (oSettings.fnServerData) {\n      // DataTables 1.9- compatibility\n      oSettings.fnServerData.call(instance, oSettings.sAjaxSource, $.map(data, function (val, key) {\n        // Need to convert back to 1.9 trad format\n        return {\n          name: key,\n          value: val\n        };\n      }), callback, oSettings);\n    } else if (oSettings.sAjaxSource || typeof ajax === 'string') {\n      // DataTables 1.9- compatibility\n      oSettings.jqXHR = $.ajax($.extend(baseAjax, {\n        url: ajax || oSettings.sAjaxSource\n      }));\n    } else if (typeof ajax === 'function') {\n      // Is a function - let the caller define what needs to be done\n      oSettings.jqXHR = ajax.call(instance, data, callback, oSettings);\n    } else {\n      // Object to extend the base settings\n      oSettings.jqXHR = $.ajax($.extend(baseAjax, ajax)); // Restore for next time around\n\n      ajax.data = ajaxData;\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   */\n\n\n  function _fnAjaxUpdate(settings) {\n    if (settings.bAjaxDataGet) {\n      settings.iDraw++;\n\n      _fnProcessingDisplay(settings, true);\n\n      _fnBuildAjax(settings, _fnAjaxParameters(settings), function (json) {\n        _fnAjaxUpdateDraw(settings, json);\n      });\n\n      return false;\n    }\n\n    return true;\n  }\n  /**\n   * Build up the parameters in an object needed for a server-side processing\n   * request. Note that this is basically done twice, is different ways - a modern\n   * method which is used by default in DataTables 1.10 which uses objects and\n   * arrays, or the 1.9- method with is name / value pairs. 1.9 method is used if\n   * the sAjaxSource option is used in the initialisation, or the legacyAjax\n   * option is set.\n   *  @param {object} oSettings dataTables settings object\n   *  @returns {bool} block the table drawing or not\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnAjaxParameters(settings) {\n    var columns = settings.aoColumns,\n        columnCount = columns.length,\n        features = settings.oFeatures,\n        preSearch = settings.oPreviousSearch,\n        preColSearch = settings.aoPreSearchCols,\n        i,\n        data = [],\n        dataProp,\n        column,\n        columnSearch,\n        sort = _fnSortFlatten(settings),\n        displayStart = settings._iDisplayStart,\n        displayLength = features.bPaginate !== false ? settings._iDisplayLength : -1;\n\n    var param = function param(name, value) {\n      data.push({\n        'name': name,\n        'value': value\n      });\n    }; // DataTables 1.9- compatible method\n\n\n    param('sEcho', settings.iDraw);\n    param('iColumns', columnCount);\n    param('sColumns', _pluck(columns, 'sName').join(','));\n    param('iDisplayStart', displayStart);\n    param('iDisplayLength', displayLength); // DataTables 1.10+ method\n\n    var d = {\n      draw: settings.iDraw,\n      columns: [],\n      order: [],\n      start: displayStart,\n      length: displayLength,\n      search: {\n        value: preSearch.sSearch,\n        regex: preSearch.bRegex\n      }\n    };\n\n    for (i = 0; i < columnCount; i++) {\n      column = columns[i];\n      columnSearch = preColSearch[i];\n      dataProp = typeof column.mData == \"function\" ? 'function' : column.mData;\n      d.columns.push({\n        data: dataProp,\n        name: column.sName,\n        searchable: column.bSearchable,\n        orderable: column.bSortable,\n        search: {\n          value: columnSearch.sSearch,\n          regex: columnSearch.bRegex\n        }\n      });\n      param(\"mDataProp_\" + i, dataProp);\n\n      if (features.bFilter) {\n        param('sSearch_' + i, columnSearch.sSearch);\n        param('bRegex_' + i, columnSearch.bRegex);\n        param('bSearchable_' + i, column.bSearchable);\n      }\n\n      if (features.bSort) {\n        param('bSortable_' + i, column.bSortable);\n      }\n    }\n\n    if (features.bFilter) {\n      param('sSearch', preSearch.sSearch);\n      param('bRegex', preSearch.bRegex);\n    }\n\n    if (features.bSort) {\n      $.each(sort, function (i, val) {\n        d.order.push({\n          column: val.col,\n          dir: val.dir\n        });\n        param('iSortCol_' + i, val.col);\n        param('sSortDir_' + i, val.dir);\n      });\n      param('iSortingCols', sort.length);\n    } // If the legacy.ajax parameter is null, then we automatically decide which\n    // form to use, based on sAjaxSource\n\n\n    var legacy = DataTable.ext.legacy.ajax;\n\n    if (legacy === null) {\n      return settings.sAjaxSource ? data : d;\n    } // Otherwise, if legacy has been specified then we use that to decide on the\n    // form\n\n\n    return legacy ? data : d;\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   */\n\n\n  function _fnAjaxUpdateDraw(settings, json) {\n    // v1.10 uses camelCase variables, while 1.9 uses Hungarian notation.\n    // Support both\n    var compat = function compat(old, modern) {\n      return json[old] !== undefined ? json[old] : json[modern];\n    };\n\n    var data = _fnAjaxDataSrc(settings, json);\n\n    var draw = compat('sEcho', 'draw');\n    var recordsTotal = compat('iTotalRecords', 'recordsTotal');\n    var recordsFiltered = compat('iTotalDisplayRecords', 'recordsFiltered');\n\n    if (draw) {\n      // Protect against out of sequence returns\n      if (draw * 1 < settings.iDraw) {\n        return;\n      }\n\n      settings.iDraw = draw * 1;\n    }\n\n    _fnClearTable(settings);\n\n    settings._iRecordsTotal = parseInt(recordsTotal, 10);\n    settings._iRecordsDisplay = parseInt(recordsFiltered, 10);\n\n    for (var i = 0, ien = data.length; i < ien; i++) {\n      _fnAddData(settings, data[i]);\n    }\n\n    settings.aiDisplay = settings.aiDisplayMaster.slice();\n    settings.bAjaxDataGet = false;\n\n    _fnDraw(settings);\n\n    if (!settings._bInitComplete) {\n      _fnInitComplete(settings, json);\n    }\n\n    settings.bAjaxDataGet = true;\n\n    _fnProcessingDisplay(settings, false);\n  }\n  /**\n   * Get the data from the JSON data source to use for drawing a table. Using\n   * `_fnGetObjectDataFn` allows the data to be sourced from a property of the\n   * source object, or from a processing function.\n   *  @param {object} oSettings dataTables settings object\n   *  @param  {object} json Data source object / array from the server\n   *  @return {array} Array of data to use\n   */\n\n\n  function _fnAjaxDataSrc(oSettings, json) {\n    var dataSrc = $.isPlainObject(oSettings.ajax) && oSettings.ajax.dataSrc !== undefined ? oSettings.ajax.dataSrc : oSettings.sAjaxDataProp; // Compatibility with 1.9-.\n    // Compatibility with 1.9-. In order to read from aaData, check if the\n    // default has been changed, if not, check for aaData\n\n    if (dataSrc === 'data') {\n      return json.aaData || json[dataSrc];\n    }\n\n    return dataSrc !== \"\" ? _fnGetObjectDataFn(dataSrc)(json) : json;\n  }\n  /**\n   * Generate the node required for filtering text\n   *  @returns {node} Filter control element\n   *  @param {object} oSettings dataTables settings object\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnFeatureHtmlFilter(settings) {\n    var classes = settings.oClasses;\n    var tableId = settings.sTableId;\n    var language = settings.oLanguage;\n    var previousSearch = settings.oPreviousSearch;\n    var features = settings.aanFeatures;\n    var input = '<input type=\"search\" class=\"' + classes.sFilterInput + '\"/>';\n    var str = language.sSearch;\n    str = str.match(/_INPUT_/) ? str.replace('_INPUT_', input) : str + input;\n    var filter = $('<div/>', {\n      'id': !features.f ? tableId + '_filter' : null,\n      'class': classes.sFilter\n    }).append($('<label/>').append(str));\n\n    var searchFn = function searchFn() {\n      /* Update all other filter input elements for the new display */\n      var n = features.f;\n      var val = !this.value ? \"\" : this.value; // mental IE8 fix :-(\n\n      /* Now do the filter */\n\n      if (val != previousSearch.sSearch) {\n        _fnFilterComplete(settings, {\n          \"sSearch\": val,\n          \"bRegex\": previousSearch.bRegex,\n          \"bSmart\": previousSearch.bSmart,\n          \"bCaseInsensitive\": previousSearch.bCaseInsensitive\n        }); // Need to redraw, without resorting\n\n\n        settings._iDisplayStart = 0;\n\n        _fnDraw(settings);\n      }\n    };\n\n    var searchDelay = settings.searchDelay !== null ? settings.searchDelay : _fnDataSource(settings) === 'ssp' ? 400 : 0;\n    var jqFilter = $('input', filter).val(previousSearch.sSearch).attr('placeholder', language.sSearchPlaceholder).on('keyup.DT search.DT input.DT paste.DT cut.DT', searchDelay ? _fnThrottle(searchFn, searchDelay) : searchFn).on('keypress.DT', function (e) {\n      /* Prevent form submission */\n      if (e.keyCode == 13) {\n        return false;\n      }\n    }).attr('aria-controls', tableId); // Update the input elements whenever the table is filtered\n\n    $(settings.nTable).on('search.dt.DT', function (ev, s) {\n      if (settings === s) {\n        // IE9 throws an 'unknown error' if document.activeElement is used\n        // inside an iframe or frame...\n        try {\n          if (jqFilter[0] !== document.activeElement) {\n            jqFilter.val(previousSearch.sSearch);\n          }\n        } catch (e) {}\n      }\n    });\n    return filter[0];\n  }\n  /**\n   * Filter the table using both the global filter and column based filtering\n   *  @param {object} oSettings dataTables settings object\n   *  @param {object} oSearch search information\n   *  @param {int} [iForce] force a research of the master array (1) or not (undefined or 0)\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnFilterComplete(oSettings, oInput, iForce) {\n    var oPrevSearch = oSettings.oPreviousSearch;\n    var aoPrevSearch = oSettings.aoPreSearchCols;\n\n    var fnSaveFilter = function fnSaveFilter(oFilter) {\n      /* Save the filtering values */\n      oPrevSearch.sSearch = oFilter.sSearch;\n      oPrevSearch.bRegex = oFilter.bRegex;\n      oPrevSearch.bSmart = oFilter.bSmart;\n      oPrevSearch.bCaseInsensitive = oFilter.bCaseInsensitive;\n    };\n\n    var fnRegex = function fnRegex(o) {\n      // Backwards compatibility with the bEscapeRegex option\n      return o.bEscapeRegex !== undefined ? !o.bEscapeRegex : o.bRegex;\n    }; // Resolve any column types that are unknown due to addition or invalidation\n    // @todo As per sort - can this be moved into an event handler?\n\n\n    _fnColumnTypes(oSettings);\n    /* In server-side processing all filtering is done by the server, so no point hanging around here */\n\n\n    if (_fnDataSource(oSettings) != 'ssp') {\n      /* Global filter */\n      _fnFilter(oSettings, oInput.sSearch, iForce, fnRegex(oInput), oInput.bSmart, oInput.bCaseInsensitive);\n\n      fnSaveFilter(oInput);\n      /* Now do the individual column filter */\n\n      for (var i = 0; i < aoPrevSearch.length; i++) {\n        _fnFilterColumn(oSettings, aoPrevSearch[i].sSearch, i, fnRegex(aoPrevSearch[i]), aoPrevSearch[i].bSmart, aoPrevSearch[i].bCaseInsensitive);\n      }\n      /* Custom filtering */\n\n\n      _fnFilterCustom(oSettings);\n    } else {\n      fnSaveFilter(oInput);\n    }\n    /* Tell the draw function we have been filtering */\n\n\n    oSettings.bFiltered = true;\n\n    _fnCallbackFire(oSettings, null, 'search', [oSettings]);\n  }\n  /**\n   * Apply custom filtering functions\n   *  @param {object} oSettings dataTables settings object\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnFilterCustom(settings) {\n    var filters = DataTable.ext.search;\n    var displayRows = settings.aiDisplay;\n    var row, rowIdx;\n\n    for (var i = 0, ien = filters.length; i < ien; i++) {\n      var rows = []; // Loop over each row and see if it should be included\n\n      for (var j = 0, jen = displayRows.length; j < jen; j++) {\n        rowIdx = displayRows[j];\n        row = settings.aoData[rowIdx];\n\n        if (filters[i](settings, row._aFilterData, rowIdx, row._aData, j)) {\n          rows.push(rowIdx);\n        }\n      } // So the array reference doesn't break set the results into the\n      // existing array\n\n\n      displayRows.length = 0;\n      $.merge(displayRows, rows);\n    }\n  }\n  /**\n   * Filter the table on a per-column basis\n   *  @param {object} oSettings dataTables settings object\n   *  @param {string} sInput string to filter on\n   *  @param {int} iColumn column to filter\n   *  @param {bool} bRegex treat search string as a regular expression or not\n   *  @param {bool} bSmart use smart filtering or not\n   *  @param {bool} bCaseInsensitive Do case insenstive matching or not\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnFilterColumn(settings, searchStr, colIdx, regex, smart, caseInsensitive) {\n    if (searchStr === '') {\n      return;\n    }\n\n    var data;\n    var out = [];\n    var display = settings.aiDisplay;\n\n    var rpSearch = _fnFilterCreateSearch(searchStr, regex, smart, caseInsensitive);\n\n    for (var i = 0; i < display.length; i++) {\n      data = settings.aoData[display[i]]._aFilterData[colIdx];\n\n      if (rpSearch.test(data)) {\n        out.push(display[i]);\n      }\n    }\n\n    settings.aiDisplay = out;\n  }\n  /**\n   * Filter the data table based on user input and draw the table\n   *  @param {object} settings dataTables settings object\n   *  @param {string} input string to filter on\n   *  @param {int} force optional - force a research of the master array (1) or not (undefined or 0)\n   *  @param {bool} regex treat as a regular expression or not\n   *  @param {bool} smart perform smart filtering or not\n   *  @param {bool} caseInsensitive Do case insenstive matching or not\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnFilter(settings, input, force, regex, smart, caseInsensitive) {\n    var rpSearch = _fnFilterCreateSearch(input, regex, smart, caseInsensitive);\n\n    var prevSearch = settings.oPreviousSearch.sSearch;\n    var displayMaster = settings.aiDisplayMaster;\n    var display, invalidated, i;\n    var filtered = []; // Need to take account of custom filtering functions - always filter\n\n    if (DataTable.ext.search.length !== 0) {\n      force = true;\n    } // Check if any of the rows were invalidated\n\n\n    invalidated = _fnFilterData(settings); // If the input is blank - we just want the full data set\n\n    if (input.length <= 0) {\n      settings.aiDisplay = displayMaster.slice();\n    } else {\n      // New search - start from the master array\n      if (invalidated || force || prevSearch.length > input.length || input.indexOf(prevSearch) !== 0 || settings.bSorted // On resort, the display master needs to be\n      // re-filtered since indexes will have changed\n      ) {\n          settings.aiDisplay = displayMaster.slice();\n        } // Search the display array\n\n\n      display = settings.aiDisplay;\n\n      for (i = 0; i < display.length; i++) {\n        if (rpSearch.test(settings.aoData[display[i]]._sFilterRow)) {\n          filtered.push(display[i]);\n        }\n      }\n\n      settings.aiDisplay = filtered;\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   */\n\n\n  function _fnFilterCreateSearch(search, regex, smart, caseInsensitive) {\n    search = regex ? search : _fnEscapeRegex(search);\n\n    if (smart) {\n      /* For smart filtering we want to allow the search to work regardless of\n       * word order. We also want double quoted text to be preserved, so word\n       * order is important - a la google. So this is what we want to\n       * generate:\n       * \n       * ^(?=.*?\\bone\\b)(?=.*?\\btwo three\\b)(?=.*?\\bfour\\b).*$\n       */\n      var a = $.map(search.match(/\"[^\"]+\"|[^ ]+/g) || [''], function (word) {\n        if (word.charAt(0) === '\"') {\n          var m = word.match(/^\"(.*)\"$/);\n          word = m ? m[1] : word;\n        }\n\n        return word.replace('\"', '');\n      });\n      search = '^(?=.*?' + a.join(')(?=.*?') + ').*$';\n    }\n\n    return new RegExp(search, caseInsensitive ? 'i' : '');\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   */\n\n\n  var _fnEscapeRegex = DataTable.util.escapeRegex;\n  var __filter_div = $('<div>')[0];\n\n  var __filter_div_textContent = __filter_div.textContent !== undefined; // Update the filtering data for each row if needed (by invalidation or first run)\n\n\n  function _fnFilterData(settings) {\n    var columns = settings.aoColumns;\n    var column;\n    var i, j, ien, jen, filterData, cellData, row;\n    var fomatters = DataTable.ext.type.search;\n    var wasInvalidated = false;\n\n    for (i = 0, ien = settings.aoData.length; i < ien; i++) {\n      row = settings.aoData[i];\n\n      if (!row._aFilterData) {\n        filterData = [];\n\n        for (j = 0, jen = columns.length; j < jen; j++) {\n          column = columns[j];\n\n          if (column.bSearchable) {\n            cellData = _fnGetCellData(settings, i, j, 'filter');\n\n            if (fomatters[column.sType]) {\n              cellData = fomatters[column.sType](cellData);\n            } // Search in DataTables 1.10 is string based. In 1.11 this\n            // should be altered to also allow strict type checking.\n\n\n            if (cellData === null) {\n              cellData = '';\n            }\n\n            if (typeof cellData !== 'string' && cellData.toString) {\n              cellData = cellData.toString();\n            }\n          } else {\n            cellData = '';\n          } // If it looks like there is an HTML entity in the string,\n          // attempt to decode it so sorting works as expected. Note that\n          // we could use a single line of jQuery to do this, but the DOM\n          // method used here is much faster http://jsperf.com/html-decode\n\n\n          if (cellData.indexOf && cellData.indexOf('&') !== -1) {\n            __filter_div.innerHTML = cellData;\n            cellData = __filter_div_textContent ? __filter_div.textContent : __filter_div.innerText;\n          }\n\n          if (cellData.replace) {\n            cellData = cellData.replace(/[\\r\\n]/g, '');\n          }\n\n          filterData.push(cellData);\n        }\n\n        row._aFilterData = filterData;\n        row._sFilterRow = filterData.join('  ');\n        wasInvalidated = true;\n      }\n    }\n\n    return wasInvalidated;\n  }\n  /**\n   * Convert from the internal Hungarian notation to camelCase for external\n   * interaction\n   *  @param {object} obj Object to convert\n   *  @returns {object} Inverted object\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnSearchToCamel(obj) {\n    return {\n      search: obj.sSearch,\n      smart: obj.bSmart,\n      regex: obj.bRegex,\n      caseInsensitive: obj.bCaseInsensitive\n    };\n  }\n  /**\n   * Convert from camelCase notation to the internal Hungarian. We could use the\n   * Hungarian convert function here, but this is cleaner\n   *  @param {object} obj Object to convert\n   *  @returns {object} Inverted object\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnSearchToHung(obj) {\n    return {\n      sSearch: obj.search,\n      bSmart: obj.smart,\n      bRegex: obj.regex,\n      bCaseInsensitive: obj.caseInsensitive\n    };\n  }\n  /**\n   * Generate the node required for the info display\n   *  @param {object} oSettings dataTables settings object\n   *  @returns {node} Information element\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnFeatureHtmlInfo(settings) {\n    var tid = settings.sTableId,\n        nodes = settings.aanFeatures.i,\n        n = $('<div/>', {\n      'class': settings.oClasses.sInfo,\n      'id': !nodes ? tid + '_info' : null\n    });\n\n    if (!nodes) {\n      // Update display on each draw\n      settings.aoDrawCallback.push({\n        \"fn\": _fnUpdateInfo,\n        \"sName\": \"information\"\n      });\n      n.attr('role', 'status').attr('aria-live', 'polite'); // Table is described by our info div\n\n      $(settings.nTable).attr('aria-describedby', tid + '_info');\n    }\n\n    return n[0];\n  }\n  /**\n   * Update the information elements in the display\n   *  @param {object} settings dataTables settings object\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnUpdateInfo(settings) {\n    /* Show information about the table */\n    var nodes = settings.aanFeatures.i;\n\n    if (nodes.length === 0) {\n      return;\n    }\n\n    var lang = settings.oLanguage,\n        start = settings._iDisplayStart + 1,\n        end = settings.fnDisplayEnd(),\n        max = settings.fnRecordsTotal(),\n        total = settings.fnRecordsDisplay(),\n        out = total ? lang.sInfo : lang.sInfoEmpty;\n\n    if (total !== max) {\n      /* Record set after filtering */\n      out += ' ' + lang.sInfoFiltered;\n    } // Convert the macros\n\n\n    out += lang.sInfoPostFix;\n    out = _fnInfoMacros(settings, out);\n    var callback = lang.fnInfoCallback;\n\n    if (callback !== null) {\n      out = callback.call(settings.oInstance, settings, start, end, max, total, out);\n    }\n\n    $(nodes).html(out);\n  }\n\n  function _fnInfoMacros(settings, str) {\n    // When infinite scrolling, we are always starting at 1. _iDisplayStart is used only\n    // internally\n    var formatter = settings.fnFormatNumber,\n        start = settings._iDisplayStart + 1,\n        len = settings._iDisplayLength,\n        vis = settings.fnRecordsDisplay(),\n        all = len === -1;\n    return str.replace(/_START_/g, formatter.call(settings, start)).replace(/_END_/g, formatter.call(settings, settings.fnDisplayEnd())).replace(/_MAX_/g, formatter.call(settings, settings.fnRecordsTotal())).replace(/_TOTAL_/g, formatter.call(settings, vis)).replace(/_PAGE_/g, formatter.call(settings, all ? 1 : Math.ceil(start / len))).replace(/_PAGES_/g, formatter.call(settings, all ? 1 : Math.ceil(vis / len)));\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   */\n\n\n  function _fnInitialise(settings) {\n    var i,\n        iLen,\n        iAjaxStart = settings.iInitDisplayStart;\n    var columns = settings.aoColumns,\n        column;\n    var features = settings.oFeatures;\n    var deferLoading = settings.bDeferLoading; // value modified by the draw\n\n    /* Ensure that the table data is fully initialised */\n\n    if (!settings.bInitialised) {\n      setTimeout(function () {\n        _fnInitialise(settings);\n      }, 200);\n      return;\n    }\n    /* Show the display HTML options */\n\n\n    _fnAddOptionsHtml(settings);\n    /* Build and draw the header / footer for the table */\n\n\n    _fnBuildHead(settings);\n\n    _fnDrawHead(settings, settings.aoHeader);\n\n    _fnDrawHead(settings, settings.aoFooter);\n    /* Okay to show that something is going on now */\n\n\n    _fnProcessingDisplay(settings, true);\n    /* Calculate sizes for columns */\n\n\n    if (features.bAutoWidth) {\n      _fnCalculateColumnWidths(settings);\n    }\n\n    for (i = 0, iLen = columns.length; i < iLen; i++) {\n      column = columns[i];\n\n      if (column.sWidth) {\n        column.nTh.style.width = _fnStringToCss(column.sWidth);\n      }\n    }\n\n    _fnCallbackFire(settings, null, 'preInit', [settings]); // If there is default sorting required - let's do it. The sort function\n    // will do the drawing for us. Otherwise we draw the table regardless of the\n    // Ajax source - this allows the table to look initialised for Ajax sourcing\n    // data (show 'loading' message possibly)\n\n\n    _fnReDraw(settings); // Server-side processing init complete is done by _fnAjaxUpdateDraw\n\n\n    var dataSrc = _fnDataSource(settings);\n\n    if (dataSrc != 'ssp' || deferLoading) {\n      // if there is an ajax source load the data\n      if (dataSrc == 'ajax') {\n        _fnBuildAjax(settings, [], function (json) {\n          var aData = _fnAjaxDataSrc(settings, json); // Got the data - add it to the table\n\n\n          for (i = 0; i < aData.length; i++) {\n            _fnAddData(settings, aData[i]);\n          } // Reset the init display for cookie saving. We've already done\n          // a filter, and therefore cleared it before. So we need to make\n          // it appear 'fresh'\n\n\n          settings.iInitDisplayStart = iAjaxStart;\n\n          _fnReDraw(settings);\n\n          _fnProcessingDisplay(settings, false);\n\n          _fnInitComplete(settings, json);\n        }, settings);\n      } else {\n        _fnProcessingDisplay(settings, false);\n\n        _fnInitComplete(settings);\n      }\n    }\n  }\n  /**\n   * Draw the table for the first time, adding all required features\n   *  @param {object} oSettings dataTables settings object\n   *  @param {object} [json] JSON from the server that completed the table, if using Ajax source\n   *    with client-side processing (optional)\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnInitComplete(settings, json) {\n    settings._bInitComplete = true; // When data was added after the initialisation (data or Ajax) we need to\n    // calculate the column sizing\n\n    if (json || settings.oInit.aaData) {\n      _fnAdjustColumnSizing(settings);\n    }\n\n    _fnCallbackFire(settings, null, 'plugin-init', [settings, json]);\n\n    _fnCallbackFire(settings, 'aoInitComplete', 'init', [settings, json]);\n  }\n\n  function _fnLengthChange(settings, val) {\n    var len = parseInt(val, 10);\n    settings._iDisplayLength = len;\n\n    _fnLengthOverflow(settings); // Fire length change event\n\n\n    _fnCallbackFire(settings, null, 'length', [settings, len]);\n  }\n  /**\n   * Generate the node required for user display length changing\n   *  @param {object} settings dataTables settings object\n   *  @returns {node} Display length feature node\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnFeatureHtmlLength(settings) {\n    var classes = settings.oClasses,\n        tableId = settings.sTableId,\n        menu = settings.aLengthMenu,\n        d2 = $.isArray(menu[0]),\n        lengths = d2 ? menu[0] : menu,\n        language = d2 ? menu[1] : menu;\n    var select = $('<select/>', {\n      'name': tableId + '_length',\n      'aria-controls': tableId,\n      'class': classes.sLengthSelect\n    });\n\n    for (var i = 0, ien = lengths.length; i < ien; i++) {\n      select[0][i] = new Option(typeof language[i] === 'number' ? settings.fnFormatNumber(language[i]) : language[i], lengths[i]);\n    }\n\n    var div = $('<div><label/></div>').addClass(classes.sLength);\n\n    if (!settings.aanFeatures.l) {\n      div[0].id = tableId + '_length';\n    }\n\n    div.children().append(settings.oLanguage.sLengthMenu.replace('_MENU_', select[0].outerHTML)); // Can't use `select` variable as user might provide their own and the\n    // reference is broken by the use of outerHTML\n\n    $('select', div).val(settings._iDisplayLength).on('change.DT', function (e) {\n      _fnLengthChange(settings, $(this).val());\n\n      _fnDraw(settings);\n    }); // Update node value whenever anything changes the table's length\n\n    $(settings.nTable).on('length.dt.DT', function (e, s, len) {\n      if (settings === s) {\n        $('select', div).val(len);\n      }\n    });\n    return div[0];\n  }\n  /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n   * Note that most of the paging logic is done in\n   * DataTable.ext.pager\n   */\n\n  /**\n   * Generate the node required for default pagination\n   *  @param {object} oSettings dataTables settings object\n   *  @returns {node} Pagination feature node\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnFeatureHtmlPaginate(settings) {\n    var type = settings.sPaginationType,\n        plugin = DataTable.ext.pager[type],\n        modern = typeof plugin === 'function',\n        redraw = function redraw(settings) {\n      _fnDraw(settings);\n    },\n        node = $('<div/>').addClass(settings.oClasses.sPaging + type)[0],\n        features = settings.aanFeatures;\n\n    if (!modern) {\n      plugin.fnInit(settings, node, redraw);\n    }\n    /* Add a draw callback for the pagination on first instance, to update the paging display */\n\n\n    if (!features.p) {\n      node.id = settings.sTableId + '_paginate';\n      settings.aoDrawCallback.push({\n        \"fn\": function fn(settings) {\n          if (modern) {\n            var start = settings._iDisplayStart,\n                len = settings._iDisplayLength,\n                visRecords = settings.fnRecordsDisplay(),\n                all = len === -1,\n                page = all ? 0 : Math.ceil(start / len),\n                pages = all ? 1 : Math.ceil(visRecords / len),\n                buttons = plugin(page, pages),\n                i,\n                ien;\n\n            for (i = 0, ien = features.p.length; i < ien; i++) {\n              _fnRenderer(settings, 'pageButton')(settings, features.p[i], i, buttons, page, pages);\n            }\n          } else {\n            plugin.fnUpdate(settings, redraw);\n          }\n        },\n        \"sName\": \"pagination\"\n      });\n    }\n\n    return node;\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   */\n\n\n  function _fnPageChange(settings, action, redraw) {\n    var start = settings._iDisplayStart,\n        len = settings._iDisplayLength,\n        records = settings.fnRecordsDisplay();\n\n    if (records === 0 || len === -1) {\n      start = 0;\n    } else if (typeof action === \"number\") {\n      start = action * len;\n\n      if (start > records) {\n        start = 0;\n      }\n    } else if (action == \"first\") {\n      start = 0;\n    } else if (action == \"previous\") {\n      start = len >= 0 ? start - len : 0;\n\n      if (start < 0) {\n        start = 0;\n      }\n    } else if (action == \"next\") {\n      if (start + len < records) {\n        start += len;\n      }\n    } else if (action == \"last\") {\n      start = Math.floor((records - 1) / len) * len;\n    } else {\n      _fnLog(settings, 0, \"Unknown paging action: \" + action, 5);\n    }\n\n    var changed = settings._iDisplayStart !== start;\n    settings._iDisplayStart = start;\n\n    if (changed) {\n      _fnCallbackFire(settings, null, 'page', [settings]);\n\n      if (redraw) {\n        _fnDraw(settings);\n      }\n    }\n\n    return changed;\n  }\n  /**\n   * Generate the node required for the processing node\n   *  @param {object} settings dataTables settings object\n   *  @returns {node} Processing element\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnFeatureHtmlProcessing(settings) {\n    return $('<div/>', {\n      'id': !settings.aanFeatures.r ? settings.sTableId + '_processing' : null,\n      'class': settings.oClasses.sProcessing\n    }).html(settings.oLanguage.sProcessing).insertBefore(settings.nTable)[0];\n  }\n  /**\n   * Display or hide the processing indicator\n   *  @param {object} settings dataTables settings object\n   *  @param {bool} show Show the processing indicator (true) or not (false)\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnProcessingDisplay(settings, show) {\n    if (settings.oFeatures.bProcessing) {\n      $(settings.aanFeatures.r).css('display', show ? 'block' : 'none');\n    }\n\n    _fnCallbackFire(settings, null, 'processing', [settings, show]);\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   */\n\n\n  function _fnFeatureHtmlTable(settings) {\n    var table = $(settings.nTable); // Add the ARIA grid role to the table\n\n    table.attr('role', 'grid'); // Scrolling from here on in\n\n    var scroll = settings.oScroll;\n\n    if (scroll.sX === '' && scroll.sY === '') {\n      return settings.nTable;\n    }\n\n    var scrollX = scroll.sX;\n    var scrollY = scroll.sY;\n    var classes = settings.oClasses;\n    var caption = table.children('caption');\n    var captionSide = caption.length ? caption[0]._captionSide : null;\n    var headerClone = $(table[0].cloneNode(false));\n    var footerClone = $(table[0].cloneNode(false));\n    var footer = table.children('tfoot');\n    var _div = '<div/>';\n\n    var size = function size(s) {\n      return !s ? null : _fnStringToCss(s);\n    };\n\n    if (!footer.length) {\n      footer = null;\n    }\n    /*\n     * The HTML structure that we want to generate in this function is:\n     *  div - scroller\n     *    div - scroll head\n     *      div - scroll head inner\n     *        table - scroll head table\n     *          thead - thead\n     *    div - scroll body\n     *      table - table (master table)\n     *        thead - thead clone for sizing\n     *        tbody - tbody\n     *    div - scroll foot\n     *      div - scroll foot inner\n     *        table - scroll foot table\n     *          tfoot - tfoot\n     */\n\n\n    var scroller = $(_div, {\n      'class': classes.sScrollWrapper\n    }).append($(_div, {\n      'class': classes.sScrollHead\n    }).css({\n      overflow: 'hidden',\n      position: 'relative',\n      border: 0,\n      width: scrollX ? size(scrollX) : '100%'\n    }).append($(_div, {\n      'class': classes.sScrollHeadInner\n    }).css({\n      'box-sizing': 'content-box',\n      width: scroll.sXInner || '100%'\n    }).append(headerClone.removeAttr('id').css('margin-left', 0).append(captionSide === 'top' ? caption : null).append(table.children('thead'))))).append($(_div, {\n      'class': classes.sScrollBody\n    }).css({\n      position: 'relative',\n      overflow: 'auto',\n      width: size(scrollX)\n    }).append(table));\n\n    if (footer) {\n      scroller.append($(_div, {\n        'class': classes.sScrollFoot\n      }).css({\n        overflow: 'hidden',\n        border: 0,\n        width: scrollX ? size(scrollX) : '100%'\n      }).append($(_div, {\n        'class': classes.sScrollFootInner\n      }).append(footerClone.removeAttr('id').css('margin-left', 0).append(captionSide === 'bottom' ? caption : null).append(table.children('tfoot')))));\n    }\n\n    var children = scroller.children();\n    var scrollHead = children[0];\n    var scrollBody = children[1];\n    var scrollFoot = footer ? children[2] : null; // When the body is scrolled, then we also want to scroll the headers\n\n    if (scrollX) {\n      $(scrollBody).on('scroll.DT', function (e) {\n        var scrollLeft = this.scrollLeft;\n        scrollHead.scrollLeft = scrollLeft;\n\n        if (footer) {\n          scrollFoot.scrollLeft = scrollLeft;\n        }\n      });\n    }\n\n    $(scrollBody).css(scrollY && scroll.bCollapse ? 'max-height' : 'height', scrollY);\n    settings.nScrollHead = scrollHead;\n    settings.nScrollBody = scrollBody;\n    settings.nScrollFoot = scrollFoot; // On redraw - align columns\n\n    settings.aoDrawCallback.push({\n      \"fn\": _fnScrollDraw,\n      \"sName\": \"scrolling\"\n    });\n    return scroller[0];\n  }\n  /**\n   * Update the header, footer and body tables for resizing - i.e. column\n   * alignment.\n   *\n   * Welcome to the most horrible function DataTables. The process that this\n   * function follows is basically:\n   *   1. Re-create the table inside the scrolling div\n   *   2. Take live measurements from the DOM\n   *   3. Apply the measurements to align the columns\n   *   4. Clean up\n   *\n   *  @param {object} settings dataTables settings object\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnScrollDraw(settings) {\n    // Given that this is such a monster function, a lot of variables are use\n    // to try and keep the minimised size as small as possible\n    var scroll = settings.oScroll,\n        scrollX = scroll.sX,\n        scrollXInner = scroll.sXInner,\n        scrollY = scroll.sY,\n        barWidth = scroll.iBarWidth,\n        divHeader = $(settings.nScrollHead),\n        divHeaderStyle = divHeader[0].style,\n        divHeaderInner = divHeader.children('div'),\n        divHeaderInnerStyle = divHeaderInner[0].style,\n        divHeaderTable = divHeaderInner.children('table'),\n        divBodyEl = settings.nScrollBody,\n        divBody = $(divBodyEl),\n        divBodyStyle = divBodyEl.style,\n        divFooter = $(settings.nScrollFoot),\n        divFooterInner = divFooter.children('div'),\n        divFooterTable = divFooterInner.children('table'),\n        header = $(settings.nTHead),\n        table = $(settings.nTable),\n        tableEl = table[0],\n        tableStyle = tableEl.style,\n        footer = settings.nTFoot ? $(settings.nTFoot) : null,\n        browser = settings.oBrowser,\n        ie67 = browser.bScrollOversize,\n        dtHeaderCells = _pluck(settings.aoColumns, 'nTh'),\n        headerTrgEls,\n        footerTrgEls,\n        headerSrcEls,\n        footerSrcEls,\n        headerCopy,\n        footerCopy,\n        headerWidths = [],\n        footerWidths = [],\n        headerContent = [],\n        footerContent = [],\n        idx,\n        correction,\n        sanityWidth,\n        zeroOut = function zeroOut(nSizer) {\n      var style = nSizer.style;\n      style.paddingTop = \"0\";\n      style.paddingBottom = \"0\";\n      style.borderTopWidth = \"0\";\n      style.borderBottomWidth = \"0\";\n      style.height = 0;\n    }; // If the scrollbar visibility has changed from the last draw, we need to\n    // adjust the column sizes as the table width will have changed to account\n    // for the scrollbar\n\n\n    var scrollBarVis = divBodyEl.scrollHeight > divBodyEl.clientHeight;\n\n    if (settings.scrollBarVis !== scrollBarVis && settings.scrollBarVis !== undefined) {\n      settings.scrollBarVis = scrollBarVis;\n\n      _fnAdjustColumnSizing(settings);\n\n      return; // adjust column sizing will call this function again\n    } else {\n      settings.scrollBarVis = scrollBarVis;\n    }\n    /*\n     * 1. Re-create the table inside the scrolling div\n     */\n    // Remove the old minimised thead and tfoot elements in the inner table\n\n\n    table.children('thead, tfoot').remove();\n\n    if (footer) {\n      footerCopy = footer.clone().prependTo(table);\n      footerTrgEls = footer.find('tr'); // the original tfoot is in its own table and must be sized\n\n      footerSrcEls = footerCopy.find('tr');\n    } // Clone the current header and footer elements and then place it into the inner table\n\n\n    headerCopy = header.clone().prependTo(table);\n    headerTrgEls = header.find('tr'); // original header is in its own table\n\n    headerSrcEls = headerCopy.find('tr');\n    headerCopy.find('th, td').removeAttr('tabindex');\n    /*\n     * 2. Take live measurements from the DOM - do not alter the DOM itself!\n     */\n    // Remove old sizing and apply the calculated column widths\n    // Get the unique column headers in the newly created (cloned) header. We want to apply the\n    // calculated sizes to this header\n\n    if (!scrollX) {\n      divBodyStyle.width = '100%';\n      divHeader[0].style.width = '100%';\n    }\n\n    $.each(_fnGetUniqueThs(settings, headerCopy), function (i, el) {\n      idx = _fnVisibleToColumnIndex(settings, i);\n      el.style.width = settings.aoColumns[idx].sWidth;\n    });\n\n    if (footer) {\n      _fnApplyToChildren(function (n) {\n        n.style.width = \"\";\n      }, footerSrcEls);\n    } // Size the table as a whole\n\n\n    sanityWidth = table.outerWidth();\n\n    if (scrollX === \"\") {\n      // No x scrolling\n      tableStyle.width = \"100%\"; // IE7 will make the width of the table when 100% include the scrollbar\n      // - which is shouldn't. When there is a scrollbar we need to take this\n      // into account.\n\n      if (ie67 && (table.find('tbody').height() > divBodyEl.offsetHeight || divBody.css('overflow-y') == \"scroll\")) {\n        tableStyle.width = _fnStringToCss(table.outerWidth() - barWidth);\n      } // Recalculate the sanity width\n\n\n      sanityWidth = table.outerWidth();\n    } else if (scrollXInner !== \"\") {\n      // legacy x scroll inner has been given - use it\n      tableStyle.width = _fnStringToCss(scrollXInner); // Recalculate the sanity width\n\n      sanityWidth = table.outerWidth();\n    } // Hidden header should have zero height, so remove padding and borders. Then\n    // set the width based on the real headers\n    // Apply all styles in one pass\n\n\n    _fnApplyToChildren(zeroOut, headerSrcEls); // Read all widths in next pass\n\n\n    _fnApplyToChildren(function (nSizer) {\n      headerContent.push(nSizer.innerHTML);\n      headerWidths.push(_fnStringToCss($(nSizer).css('width')));\n    }, headerSrcEls); // Apply all widths in final pass\n\n\n    _fnApplyToChildren(function (nToSize, i) {\n      // Only apply widths to the DataTables detected header cells - this\n      // prevents complex headers from having contradictory sizes applied\n      if ($.inArray(nToSize, dtHeaderCells) !== -1) {\n        nToSize.style.width = headerWidths[i];\n      }\n    }, headerTrgEls);\n\n    $(headerSrcEls).height(0);\n    /* Same again with the footer if we have one */\n\n    if (footer) {\n      _fnApplyToChildren(zeroOut, footerSrcEls);\n\n      _fnApplyToChildren(function (nSizer) {\n        footerContent.push(nSizer.innerHTML);\n        footerWidths.push(_fnStringToCss($(nSizer).css('width')));\n      }, footerSrcEls);\n\n      _fnApplyToChildren(function (nToSize, i) {\n        nToSize.style.width = footerWidths[i];\n      }, footerTrgEls);\n\n      $(footerSrcEls).height(0);\n    }\n    /*\n     * 3. Apply the measurements\n     */\n    // \"Hide\" the header and footer that we used for the sizing. We need to keep\n    // the content of the cell so that the width applied to the header and body\n    // both match, but we want to hide it completely. We want to also fix their\n    // width to what they currently are\n\n\n    _fnApplyToChildren(function (nSizer, i) {\n      nSizer.innerHTML = '<div class=\"dataTables_sizing\">' + headerContent[i] + '</div>';\n      nSizer.childNodes[0].style.height = \"0\";\n      nSizer.childNodes[0].style.overflow = \"hidden\";\n      nSizer.style.width = headerWidths[i];\n    }, headerSrcEls);\n\n    if (footer) {\n      _fnApplyToChildren(function (nSizer, i) {\n        nSizer.innerHTML = '<div class=\"dataTables_sizing\">' + footerContent[i] + '</div>';\n        nSizer.childNodes[0].style.height = \"0\";\n        nSizer.childNodes[0].style.overflow = \"hidden\";\n        nSizer.style.width = footerWidths[i];\n      }, footerSrcEls);\n    } // Sanity check that the table is of a sensible width. If not then we are going to get\n    // misalignment - try to prevent this by not allowing the table to shrink below its min width\n\n\n    if (table.outerWidth() < sanityWidth) {\n      // The min width depends upon if we have a vertical scrollbar visible or not */\n      correction = divBodyEl.scrollHeight > divBodyEl.offsetHeight || divBody.css('overflow-y') == \"scroll\" ? sanityWidth + barWidth : sanityWidth; // IE6/7 are a law unto themselves...\n\n      if (ie67 && (divBodyEl.scrollHeight > divBodyEl.offsetHeight || divBody.css('overflow-y') == \"scroll\")) {\n        tableStyle.width = _fnStringToCss(correction - barWidth);\n      } // And give the user a warning that we've stopped the table getting too small\n\n\n      if (scrollX === \"\" || scrollXInner !== \"\") {\n        _fnLog(settings, 1, 'Possible column misalignment', 6);\n      }\n    } else {\n      correction = '100%';\n    } // Apply to the container elements\n\n\n    divBodyStyle.width = _fnStringToCss(correction);\n    divHeaderStyle.width = _fnStringToCss(correction);\n\n    if (footer) {\n      settings.nScrollFoot.style.width = _fnStringToCss(correction);\n    }\n    /*\n     * 4. Clean up\n     */\n\n\n    if (!scrollY) {\n      /* IE7< puts a vertical scrollbar in place (when it shouldn't be) due to subtracting\n       * the scrollbar height from the visible display, rather than adding it on. We need to\n       * set the height in order to sort this. Don't want to do it in any other browsers.\n       */\n      if (ie67) {\n        divBodyStyle.height = _fnStringToCss(tableEl.offsetHeight + barWidth);\n      }\n    }\n    /* Finally set the width's of the header and footer tables */\n\n\n    var iOuterWidth = table.outerWidth();\n    divHeaderTable[0].style.width = _fnStringToCss(iOuterWidth);\n    divHeaderInnerStyle.width = _fnStringToCss(iOuterWidth); // Figure out if there are scrollbar present - if so then we need a the header and footer to\n    // provide a bit more space to allow \"overflow\" scrolling (i.e. past the scrollbar)\n\n    var bScrolling = table.height() > divBodyEl.clientHeight || divBody.css('overflow-y') == \"scroll\";\n    var padding = 'padding' + (browser.bScrollbarLeft ? 'Left' : 'Right');\n    divHeaderInnerStyle[padding] = bScrolling ? barWidth + \"px\" : \"0px\";\n\n    if (footer) {\n      divFooterTable[0].style.width = _fnStringToCss(iOuterWidth);\n      divFooterInner[0].style.width = _fnStringToCss(iOuterWidth);\n      divFooterInner[0].style[padding] = bScrolling ? barWidth + \"px\" : \"0px\";\n    } // Correct DOM ordering for colgroup - comes before the thead\n\n\n    table.children('colgroup').insertBefore(table.children('thead'));\n    /* Adjust the position of the header in case we loose the y-scrollbar */\n\n    divBody.scroll(); // If sorting or filtering has occurred, jump the scrolling back to the top\n    // only if we aren't holding the position\n\n    if ((settings.bSorted || settings.bFiltered) && !settings._drawHold) {\n      divBodyEl.scrollTop = 0;\n    }\n  }\n  /**\n   * Apply a given function to the display child nodes of an element array (typically\n   * TD children of TR rows\n   *  @param {function} fn Method to apply to the objects\n   *  @param array {nodes} an1 List of elements to look through for display children\n   *  @param array {nodes} an2 Another list (identical structure to the first) - optional\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnApplyToChildren(fn, an1, an2) {\n    var index = 0,\n        i = 0,\n        iLen = an1.length;\n    var nNode1, nNode2;\n\n    while (i < iLen) {\n      nNode1 = an1[i].firstChild;\n      nNode2 = an2 ? an2[i].firstChild : null;\n\n      while (nNode1) {\n        if (nNode1.nodeType === 1) {\n          if (an2) {\n            fn(nNode1, nNode2, index);\n          } else {\n            fn(nNode1, index);\n          }\n\n          index++;\n        }\n\n        nNode1 = nNode1.nextSibling;\n        nNode2 = an2 ? nNode2.nextSibling : null;\n      }\n\n      i++;\n    }\n  }\n\n  var __re_html_remove = /<.*?>/g;\n  /**\n   * Calculate the width of columns for the table\n   *  @param {object} oSettings dataTables settings object\n   *  @memberof DataTable#oApi\n   */\n\n  function _fnCalculateColumnWidths(oSettings) {\n    var table = oSettings.nTable,\n        columns = oSettings.aoColumns,\n        scroll = oSettings.oScroll,\n        scrollY = scroll.sY,\n        scrollX = scroll.sX,\n        scrollXInner = scroll.sXInner,\n        columnCount = columns.length,\n        visibleColumns = _fnGetColumns(oSettings, 'bVisible'),\n        headerCells = $('th', oSettings.nTHead),\n        tableWidthAttr = table.getAttribute('width'),\n        // from DOM element\n    tableContainer = table.parentNode,\n        userInputs = false,\n        i,\n        column,\n        columnIdx,\n        width,\n        outerWidth,\n        browser = oSettings.oBrowser,\n        ie67 = browser.bScrollOversize;\n\n    var styleWidth = table.style.width;\n\n    if (styleWidth && styleWidth.indexOf('%') !== -1) {\n      tableWidthAttr = styleWidth;\n    }\n    /* Convert any user input sizes into pixel sizes */\n\n\n    for (i = 0; i < visibleColumns.length; i++) {\n      column = columns[visibleColumns[i]];\n\n      if (column.sWidth !== null) {\n        column.sWidth = _fnConvertToWidth(column.sWidthOrig, tableContainer);\n        userInputs = true;\n      }\n    }\n    /* If the number of columns in the DOM equals the number that we have to\n     * process in DataTables, then we can use the offsets that are created by\n     * the web- browser. No custom sizes can be set in order for this to happen,\n     * nor scrolling used\n     */\n\n\n    if (ie67 || !userInputs && !scrollX && !scrollY && columnCount == _fnVisbleColumns(oSettings) && columnCount == headerCells.length) {\n      for (i = 0; i < columnCount; i++) {\n        var colIdx = _fnVisibleToColumnIndex(oSettings, i);\n\n        if (colIdx !== null) {\n          columns[colIdx].sWidth = _fnStringToCss(headerCells.eq(i).width());\n        }\n      }\n    } else {\n      // Otherwise construct a single row, worst case, table with the widest\n      // node in the data, assign any user defined widths, then insert it into\n      // the DOM and allow the browser to do all the hard work of calculating\n      // table widths\n      var tmpTable = $(table).clone() // don't use cloneNode - IE8 will remove events on the main table\n      .css('visibility', 'hidden').removeAttr('id'); // Clean up the table body\n\n      tmpTable.find('tbody tr').remove();\n      var tr = $('<tr/>').appendTo(tmpTable.find('tbody')); // Clone the table header and footer - we can't use the header / footer\n      // from the cloned table, since if scrolling is active, the table's\n      // real header and footer are contained in different table tags\n\n      tmpTable.find('thead, tfoot').remove();\n      tmpTable.append($(oSettings.nTHead).clone()).append($(oSettings.nTFoot).clone()); // Remove any assigned widths from the footer (from scrolling)\n\n      tmpTable.find('tfoot th, tfoot td').css('width', ''); // Apply custom sizing to the cloned header\n\n      headerCells = _fnGetUniqueThs(oSettings, tmpTable.find('thead')[0]);\n\n      for (i = 0; i < visibleColumns.length; i++) {\n        column = columns[visibleColumns[i]];\n        headerCells[i].style.width = column.sWidthOrig !== null && column.sWidthOrig !== '' ? _fnStringToCss(column.sWidthOrig) : ''; // For scrollX we need to force the column width otherwise the\n        // browser will collapse it. If this width is smaller than the\n        // width the column requires, then it will have no effect\n\n        if (column.sWidthOrig && scrollX) {\n          $(headerCells[i]).append($('<div/>').css({\n            width: column.sWidthOrig,\n            margin: 0,\n            padding: 0,\n            border: 0,\n            height: 1\n          }));\n        }\n      } // Find the widest cell for each column and put it into the table\n\n\n      if (oSettings.aoData.length) {\n        for (i = 0; i < visibleColumns.length; i++) {\n          columnIdx = visibleColumns[i];\n          column = columns[columnIdx];\n          $(_fnGetWidestNode(oSettings, columnIdx)).clone(false).append(column.sContentPadding).appendTo(tr);\n        }\n      } // Tidy the temporary table - remove name attributes so there aren't\n      // duplicated in the dom (radio elements for example)\n\n\n      $('[name]', tmpTable).removeAttr('name'); // Table has been built, attach to the document so we can work with it.\n      // A holding element is used, positioned at the top of the container\n      // with minimal height, so it has no effect on if the container scrolls\n      // or not. Otherwise it might trigger scrolling when it actually isn't\n      // needed\n\n      var holder = $('<div/>').css(scrollX || scrollY ? {\n        position: 'absolute',\n        top: 0,\n        left: 0,\n        height: 1,\n        right: 0,\n        overflow: 'hidden'\n      } : {}).append(tmpTable).appendTo(tableContainer); // When scrolling (X or Y) we want to set the width of the table as \n      // appropriate. However, when not scrolling leave the table width as it\n      // is. This results in slightly different, but I think correct behaviour\n\n      if (scrollX && scrollXInner) {\n        tmpTable.width(scrollXInner);\n      } else if (scrollX) {\n        tmpTable.css('width', 'auto');\n        tmpTable.removeAttr('width'); // If there is no width attribute or style, then allow the table to\n        // collapse\n\n        if (tmpTable.width() < tableContainer.clientWidth && tableWidthAttr) {\n          tmpTable.width(tableContainer.clientWidth);\n        }\n      } else if (scrollY) {\n        tmpTable.width(tableContainer.clientWidth);\n      } else if (tableWidthAttr) {\n        tmpTable.width(tableWidthAttr);\n      } // Get the width of each column in the constructed table - we need to\n      // know the inner width (so it can be assigned to the other table's\n      // cells) and the outer width so we can calculate the full width of the\n      // table. This is safe since DataTables requires a unique cell for each\n      // column, but if ever a header can span multiple columns, this will\n      // need to be modified.\n\n\n      var total = 0;\n\n      for (i = 0; i < visibleColumns.length; i++) {\n        var cell = $(headerCells[i]);\n        var border = cell.outerWidth() - cell.width(); // Use getBounding... where possible (not IE8-) because it can give\n        // sub-pixel accuracy, which we then want to round up!\n\n        var bounding = browser.bBounding ? Math.ceil(headerCells[i].getBoundingClientRect().width) : cell.outerWidth(); // Total is tracked to remove any sub-pixel errors as the outerWidth\n        // of the table might not equal the total given here (IE!).\n\n        total += bounding; // Width for each column to use\n\n        columns[visibleColumns[i]].sWidth = _fnStringToCss(bounding - border);\n      }\n\n      table.style.width = _fnStringToCss(total); // Finished with the table - ditch it\n\n      holder.remove();\n    } // If there is a width attr, we want to attach an event listener which\n    // allows the table sizing to automatically adjust when the window is\n    // resized. Use the width attr rather than CSS, since we can't know if the\n    // CSS is a relative value or absolute - DOM read is always px.\n\n\n    if (tableWidthAttr) {\n      table.style.width = _fnStringToCss(tableWidthAttr);\n    }\n\n    if ((tableWidthAttr || scrollX) && !oSettings._reszEvt) {\n      var bindResize = function bindResize() {\n        $(window).on('resize.DT-' + oSettings.sInstance, _fnThrottle(function () {\n          _fnAdjustColumnSizing(oSettings);\n        }));\n      }; // IE6/7 will crash if we bind a resize event handler on page load.\n      // To be removed in 1.11 which drops IE6/7 support\n\n\n      if (ie67) {\n        setTimeout(bindResize, 1000);\n      } else {\n        bindResize();\n      }\n\n      oSettings._reszEvt = true;\n    }\n  }\n  /**\n   * Throttle the calls to a function. Arguments and context are maintained for\n   * the throttled function\n   *  @param {function} fn Function to be called\n   *  @param {int} [freq=200] call frequency in mS\n   *  @returns {function} wrapped function\n   *  @memberof DataTable#oApi\n   */\n\n\n  var _fnThrottle = DataTable.util.throttle;\n  /**\n   * Convert a CSS unit width to pixels (e.g. 2em)\n   *  @param {string} width width to be converted\n   *  @param {node} parent parent to get the with for (required for relative widths) - optional\n   *  @returns {int} width in pixels\n   *  @memberof DataTable#oApi\n   */\n\n  function _fnConvertToWidth(width, parent) {\n    if (!width) {\n      return 0;\n    }\n\n    var n = $('<div/>').css('width', _fnStringToCss(width)).appendTo(parent || document.body);\n    var val = n[0].offsetWidth;\n    n.remove();\n    return val;\n  }\n  /**\n   * Get the widest node\n   *  @param {object} settings dataTables settings object\n   *  @param {int} colIdx column of interest\n   *  @returns {node} widest table node\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnGetWidestNode(settings, colIdx) {\n    var idx = _fnGetMaxLenString(settings, colIdx);\n\n    if (idx < 0) {\n      return null;\n    }\n\n    var data = settings.aoData[idx];\n    return !data.nTr ? // Might not have been created when deferred rendering\n    $('<td/>').html(_fnGetCellData(settings, idx, colIdx, 'display'))[0] : data.anCells[colIdx];\n  }\n  /**\n   * Get the maximum strlen for each data column\n   *  @param {object} settings dataTables settings object\n   *  @param {int} colIdx column of interest\n   *  @returns {string} max string length for each column\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnGetMaxLenString(settings, colIdx) {\n    var s,\n        max = -1,\n        maxIdx = -1;\n\n    for (var i = 0, ien = settings.aoData.length; i < ien; i++) {\n      s = _fnGetCellData(settings, i, colIdx, 'display') + '';\n      s = s.replace(__re_html_remove, '');\n      s = s.replace(/&nbsp;/g, ' ');\n\n      if (s.length > max) {\n        max = s.length;\n        maxIdx = i;\n      }\n    }\n\n    return maxIdx;\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   */\n\n\n  function _fnStringToCss(s) {\n    if (s === null) {\n      return '0px';\n    }\n\n    if (typeof s == 'number') {\n      return s < 0 ? '0px' : s + 'px';\n    } // Check it has a unit character already\n\n\n    return s.match(/\\d$/) ? s + 'px' : s;\n  }\n\n  function _fnSortFlatten(settings) {\n    var i,\n        iLen,\n        k,\n        kLen,\n        aSort = [],\n        aiOrig = [],\n        aoColumns = settings.aoColumns,\n        aDataSort,\n        iCol,\n        sType,\n        srcCol,\n        fixed = settings.aaSortingFixed,\n        fixedObj = $.isPlainObject(fixed),\n        nestedSort = [],\n        add = function add(a) {\n      if (a.length && !$.isArray(a[0])) {\n        // 1D array\n        nestedSort.push(a);\n      } else {\n        // 2D array\n        $.merge(nestedSort, a);\n      }\n    }; // Build the sort array, with pre-fix and post-fix options if they have been\n    // specified\n\n\n    if ($.isArray(fixed)) {\n      add(fixed);\n    }\n\n    if (fixedObj && fixed.pre) {\n      add(fixed.pre);\n    }\n\n    add(settings.aaSorting);\n\n    if (fixedObj && fixed.post) {\n      add(fixed.post);\n    }\n\n    for (i = 0; i < nestedSort.length; i++) {\n      srcCol = nestedSort[i][0];\n      aDataSort = aoColumns[srcCol].aDataSort;\n\n      for (k = 0, kLen = aDataSort.length; k < kLen; k++) {\n        iCol = aDataSort[k];\n        sType = aoColumns[iCol].sType || 'string';\n\n        if (nestedSort[i]._idx === undefined) {\n          nestedSort[i]._idx = $.inArray(nestedSort[i][1], aoColumns[iCol].asSorting);\n        }\n\n        aSort.push({\n          src: srcCol,\n          col: iCol,\n          dir: nestedSort[i][1],\n          index: nestedSort[i]._idx,\n          type: sType,\n          formatter: DataTable.ext.type.order[sType + \"-pre\"]\n        });\n      }\n    }\n\n    return aSort;\n  }\n  /**\n   * Change the order of the table\n   *  @param {object} oSettings dataTables settings object\n   *  @memberof DataTable#oApi\n   *  @todo This really needs split up!\n   */\n\n\n  function _fnSort(oSettings) {\n    var i,\n        ien,\n        iLen,\n        j,\n        jLen,\n        k,\n        kLen,\n        sDataType,\n        nTh,\n        aiOrig = [],\n        oExtSort = DataTable.ext.type.order,\n        aoData = oSettings.aoData,\n        aoColumns = oSettings.aoColumns,\n        aDataSort,\n        data,\n        iCol,\n        sType,\n        oSort,\n        formatters = 0,\n        sortCol,\n        displayMaster = oSettings.aiDisplayMaster,\n        aSort; // Resolve any column types that are unknown due to addition or invalidation\n    // @todo Can this be moved into a 'data-ready' handler which is called when\n    //   data is going to be used in the table?\n\n    _fnColumnTypes(oSettings);\n\n    aSort = _fnSortFlatten(oSettings);\n\n    for (i = 0, ien = aSort.length; i < ien; i++) {\n      sortCol = aSort[i]; // Track if we can use the fast sort algorithm\n\n      if (sortCol.formatter) {\n        formatters++;\n      } // Load the data needed for the sort, for each cell\n\n\n      _fnSortData(oSettings, sortCol.col);\n    }\n    /* No sorting required if server-side or no sorting array */\n\n\n    if (_fnDataSource(oSettings) != 'ssp' && aSort.length !== 0) {\n      // Create a value - key array of the current row positions such that we can use their\n      // current position during the sort, if values match, in order to perform stable sorting\n      for (i = 0, iLen = displayMaster.length; i < iLen; i++) {\n        aiOrig[displayMaster[i]] = i;\n      }\n      /* Do the sort - here we want multi-column sorting based on a given data source (column)\n       * and sorting function (from oSort) in a certain direction. It's reasonably complex to\n       * follow on it's own, but this is what we want (example two column sorting):\n       *  fnLocalSorting = function(a,b){\n       *    var iTest;\n       *    iTest = oSort['string-asc']('data11', 'data12');\n       *      if (iTest !== 0)\n       *        return iTest;\n       *    iTest = oSort['numeric-desc']('data21', 'data22');\n       *    if (iTest !== 0)\n       *      return iTest;\n       *    return oSort['numeric-asc']( aiOrig[a], aiOrig[b] );\n       *  }\n       * Basically we have a test for each sorting column, if the data in that column is equal,\n       * test the next column. If all columns match, then we use a numeric sort on the row\n       * positions in the original data array to provide a stable sort.\n       *\n       * Note - I know it seems excessive to have two sorting methods, but the first is around\n       * 15% faster, so the second is only maintained for backwards compatibility with sorting\n       * methods which do not have a pre-sort formatting function.\n       */\n\n\n      if (formatters === aSort.length) {\n        // All sort types have formatting functions\n        displayMaster.sort(function (a, b) {\n          var x,\n              y,\n              k,\n              test,\n              sort,\n              len = aSort.length,\n              dataA = aoData[a]._aSortData,\n              dataB = aoData[b]._aSortData;\n\n          for (k = 0; k < len; k++) {\n            sort = aSort[k];\n            x = dataA[sort.col];\n            y = dataB[sort.col];\n            test = x < y ? -1 : x > y ? 1 : 0;\n\n            if (test !== 0) {\n              return sort.dir === 'asc' ? test : -test;\n            }\n          }\n\n          x = aiOrig[a];\n          y = aiOrig[b];\n          return x < y ? -1 : x > y ? 1 : 0;\n        });\n      } else {\n        // Depreciated - remove in 1.11 (providing a plug-in option)\n        // Not all sort types have formatting methods, so we have to call their sorting\n        // methods.\n        displayMaster.sort(function (a, b) {\n          var x,\n              y,\n              k,\n              l,\n              test,\n              sort,\n              fn,\n              len = aSort.length,\n              dataA = aoData[a]._aSortData,\n              dataB = aoData[b]._aSortData;\n\n          for (k = 0; k < len; k++) {\n            sort = aSort[k];\n            x = dataA[sort.col];\n            y = dataB[sort.col];\n            fn = oExtSort[sort.type + \"-\" + sort.dir] || oExtSort[\"string-\" + sort.dir];\n            test = fn(x, y);\n\n            if (test !== 0) {\n              return test;\n            }\n          }\n\n          x = aiOrig[a];\n          y = aiOrig[b];\n          return x < y ? -1 : x > y ? 1 : 0;\n        });\n      }\n    }\n    /* Tell the draw function that we have sorted the data */\n\n\n    oSettings.bSorted = true;\n  }\n\n  function _fnSortAria(settings) {\n    var label;\n    var nextSort;\n    var columns = settings.aoColumns;\n\n    var aSort = _fnSortFlatten(settings);\n\n    var oAria = settings.oLanguage.oAria; // ARIA attributes - need to loop all columns, to update all (removing old\n    // attributes as needed)\n\n    for (var i = 0, iLen = columns.length; i < iLen; i++) {\n      var col = columns[i];\n      var asSorting = col.asSorting;\n      var sTitle = col.sTitle.replace(/<.*?>/g, \"\");\n      var th = col.nTh; // IE7 is throwing an error when setting these properties with jQuery's\n      // attr() and removeAttr() methods...\n\n      th.removeAttribute('aria-sort');\n      /* In ARIA only the first sorting column can be marked as sorting - no multi-sort option */\n\n      if (col.bSortable) {\n        if (aSort.length > 0 && aSort[0].col == i) {\n          th.setAttribute('aria-sort', aSort[0].dir == \"asc\" ? \"ascending\" : \"descending\");\n          nextSort = asSorting[aSort[0].index + 1] || asSorting[0];\n        } else {\n          nextSort = asSorting[0];\n        }\n\n        label = sTitle + (nextSort === \"asc\" ? oAria.sSortAscending : oAria.sSortDescending);\n      } else {\n        label = sTitle;\n      }\n\n      th.setAttribute('aria-label', label);\n    }\n  }\n  /**\n   * Function to run on user sort request\n   *  @param {object} settings dataTables settings object\n   *  @param {node} attachTo node to attach the handler to\n   *  @param {int} colIdx column sorting index\n   *  @param {boolean} [append=false] Append the requested sort to the existing\n   *    sort if true (i.e. multi-column sort)\n   *  @param {function} [callback] callback function\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnSortListener(settings, colIdx, append, callback) {\n    var col = settings.aoColumns[colIdx];\n    var sorting = settings.aaSorting;\n    var asSorting = col.asSorting;\n    var nextSortIdx;\n\n    var next = function next(a, overflow) {\n      var idx = a._idx;\n\n      if (idx === undefined) {\n        idx = $.inArray(a[1], asSorting);\n      }\n\n      return idx + 1 < asSorting.length ? idx + 1 : overflow ? null : 0;\n    }; // Convert to 2D array if needed\n\n\n    if (typeof sorting[0] === 'number') {\n      sorting = settings.aaSorting = [sorting];\n    } // If appending the sort then we are multi-column sorting\n\n\n    if (append && settings.oFeatures.bSortMulti) {\n      // Are we already doing some kind of sort on this column?\n      var sortIdx = $.inArray(colIdx, _pluck(sorting, '0'));\n\n      if (sortIdx !== -1) {\n        // Yes, modify the sort\n        nextSortIdx = next(sorting[sortIdx], true);\n\n        if (nextSortIdx === null && sorting.length === 1) {\n          nextSortIdx = 0; // can't remove sorting completely\n        }\n\n        if (nextSortIdx === null) {\n          sorting.splice(sortIdx, 1);\n        } else {\n          sorting[sortIdx][1] = asSorting[nextSortIdx];\n          sorting[sortIdx]._idx = nextSortIdx;\n        }\n      } else {\n        // No sort on this column yet\n        sorting.push([colIdx, asSorting[0], 0]);\n        sorting[sorting.length - 1]._idx = 0;\n      }\n    } else if (sorting.length && sorting[0][0] == colIdx) {\n      // Single column - already sorting on this column, modify the sort\n      nextSortIdx = next(sorting[0]);\n      sorting.length = 1;\n      sorting[0][1] = asSorting[nextSortIdx];\n      sorting[0]._idx = nextSortIdx;\n    } else {\n      // Single column - sort only on this column\n      sorting.length = 0;\n      sorting.push([colIdx, asSorting[0]]);\n      sorting[0]._idx = 0;\n    } // Run the sort by calling a full redraw\n\n\n    _fnReDraw(settings); // callback used for async user interaction\n\n\n    if (typeof callback == 'function') {\n      callback(settings);\n    }\n  }\n  /**\n   * Attach a sort handler (click) to a node\n   *  @param {object} settings dataTables settings object\n   *  @param {node} attachTo node to attach the handler to\n   *  @param {int} colIdx column sorting index\n   *  @param {function} [callback] callback function\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnSortAttachListener(settings, attachTo, colIdx, callback) {\n    var col = settings.aoColumns[colIdx];\n\n    _fnBindAction(attachTo, {}, function (e) {\n      /* If the column is not sortable - don't to anything */\n      if (col.bSortable === false) {\n        return;\n      } // If processing is enabled use a timeout to allow the processing\n      // display to be shown - otherwise to it synchronously\n\n\n      if (settings.oFeatures.bProcessing) {\n        _fnProcessingDisplay(settings, true);\n\n        setTimeout(function () {\n          _fnSortListener(settings, colIdx, e.shiftKey, callback); // In server-side processing, the draw callback will remove the\n          // processing display\n\n\n          if (_fnDataSource(settings) !== 'ssp') {\n            _fnProcessingDisplay(settings, false);\n          }\n        }, 0);\n      } else {\n        _fnSortListener(settings, colIdx, e.shiftKey, callback);\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   */\n\n\n  function _fnSortingClasses(settings) {\n    var oldSort = settings.aLastSort;\n    var sortClass = settings.oClasses.sSortColumn;\n\n    var sort = _fnSortFlatten(settings);\n\n    var features = settings.oFeatures;\n    var i, ien, colIdx;\n\n    if (features.bSort && features.bSortClasses) {\n      // Remove old sorting classes\n      for (i = 0, ien = oldSort.length; i < ien; i++) {\n        colIdx = oldSort[i].src; // Remove column sorting\n\n        $(_pluck(settings.aoData, 'anCells', colIdx)).removeClass(sortClass + (i < 2 ? i + 1 : 3));\n      } // Add new column sorting\n\n\n      for (i = 0, ien = sort.length; i < ien; i++) {\n        colIdx = sort[i].src;\n        $(_pluck(settings.aoData, 'anCells', colIdx)).addClass(sortClass + (i < 2 ? i + 1 : 3));\n      }\n    }\n\n    settings.aLastSort = sort;\n  } // Get the data to sort a column, be it from cache, fresh (populating the\n  // cache), or from a sort formatter\n\n\n  function _fnSortData(settings, idx) {\n    // Custom sorting function - provided by the sort data type\n    var column = settings.aoColumns[idx];\n    var customSort = DataTable.ext.order[column.sSortDataType];\n    var customData;\n\n    if (customSort) {\n      customData = customSort.call(settings.oInstance, settings, idx, _fnColumnIndexToVisible(settings, idx));\n    } // Use / populate cache\n\n\n    var row, cellData;\n    var formatter = DataTable.ext.type.order[column.sType + \"-pre\"];\n\n    for (var i = 0, ien = settings.aoData.length; i < ien; i++) {\n      row = settings.aoData[i];\n\n      if (!row._aSortData) {\n        row._aSortData = [];\n      }\n\n      if (!row._aSortData[idx] || customSort) {\n        cellData = customSort ? customData[i] : // If there was a custom sort function, use data from there\n        _fnGetCellData(settings, i, idx, 'sort');\n        row._aSortData[idx] = formatter ? formatter(cellData) : cellData;\n      }\n    }\n  }\n  /**\n   * Save the state of a table\n   *  @param {object} oSettings dataTables settings object\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnSaveState(settings) {\n    if (!settings.oFeatures.bStateSave || settings.bDestroying) {\n      return;\n    }\n    /* Store the interesting variables */\n\n\n    var state = {\n      time: +new Date(),\n      start: settings._iDisplayStart,\n      length: settings._iDisplayLength,\n      order: $.extend(true, [], settings.aaSorting),\n      search: _fnSearchToCamel(settings.oPreviousSearch),\n      columns: $.map(settings.aoColumns, function (col, i) {\n        return {\n          visible: col.bVisible,\n          search: _fnSearchToCamel(settings.aoPreSearchCols[i])\n        };\n      })\n    };\n\n    _fnCallbackFire(settings, \"aoStateSaveParams\", 'stateSaveParams', [settings, state]);\n\n    settings.oSavedState = state;\n    settings.fnStateSaveCallback.call(settings.oInstance, settings, state);\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   */\n\n\n  function _fnLoadState(settings, oInit, callback) {\n    var i, ien;\n    var columns = settings.aoColumns;\n\n    var loaded = function loaded(s) {\n      if (!s || !s.time) {\n        callback();\n        return;\n      } // Allow custom and plug-in manipulation functions to alter the saved data set and\n      // cancelling of loading by returning false\n\n\n      var abStateLoad = _fnCallbackFire(settings, 'aoStateLoadParams', 'stateLoadParams', [settings, s]);\n\n      if ($.inArray(false, abStateLoad) !== -1) {\n        callback();\n        return;\n      } // Reject old data\n\n\n      var duration = settings.iStateDuration;\n\n      if (duration > 0 && s.time < +new Date() - duration * 1000) {\n        callback();\n        return;\n      } // Number of columns have changed - all bets are off, no restore of settings\n\n\n      if (s.columns && columns.length !== s.columns.length) {\n        callback();\n        return;\n      } // Store the saved state so it might be accessed at any time\n\n\n      settings.oLoadedState = $.extend(true, {}, s); // Restore key features - todo - for 1.11 this needs to be done by\n      // subscribed events\n\n      if (s.start !== undefined) {\n        settings._iDisplayStart = s.start;\n        settings.iInitDisplayStart = s.start;\n      }\n\n      if (s.length !== undefined) {\n        settings._iDisplayLength = s.length;\n      } // Order\n\n\n      if (s.order !== undefined) {\n        settings.aaSorting = [];\n        $.each(s.order, function (i, col) {\n          settings.aaSorting.push(col[0] >= columns.length ? [0, col[1]] : col);\n        });\n      } // Search\n\n\n      if (s.search !== undefined) {\n        $.extend(settings.oPreviousSearch, _fnSearchToHung(s.search));\n      } // Columns\n      //\n\n\n      if (s.columns) {\n        for (i = 0, ien = s.columns.length; i < ien; i++) {\n          var col = s.columns[i]; // Visibility\n\n          if (col.visible !== undefined) {\n            columns[i].bVisible = col.visible;\n          } // Search\n\n\n          if (col.search !== undefined) {\n            $.extend(settings.aoPreSearchCols[i], _fnSearchToHung(col.search));\n          }\n        }\n      }\n\n      _fnCallbackFire(settings, 'aoStateLoaded', 'stateLoaded', [settings, s]);\n\n      callback();\n    };\n\n    if (!settings.oFeatures.bStateSave) {\n      callback();\n      return;\n    }\n\n    var state = settings.fnStateLoadCallback.call(settings.oInstance, settings, loaded);\n\n    if (state !== undefined) {\n      loaded(state);\n    } // otherwise, wait for the loaded callback to be executed\n\n  }\n  /**\n   * Return the settings object for a particular table\n   *  @param {node} table table we are using as a dataTable\n   *  @returns {object} Settings object - or null if not found\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnSettingsFromNode(table) {\n    var settings = DataTable.settings;\n    var idx = $.inArray(table, _pluck(settings, 'nTable'));\n    return idx !== -1 ? settings[idx] : null;\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   */\n\n\n  function _fnLog(settings, level, msg, tn) {\n    msg = 'DataTables warning: ' + (settings ? 'table id=' + settings.sTableId + ' - ' : '') + msg;\n\n    if (tn) {\n      msg += '. For more information about this error, please see ' + 'http://datatables.net/tn/' + tn;\n    }\n\n    if (!level) {\n      // Backwards compatibility pre 1.10\n      var ext = DataTable.ext;\n      var type = ext.sErrMode || ext.errMode;\n\n      if (settings) {\n        _fnCallbackFire(settings, null, 'error', [settings, tn, msg]);\n      }\n\n      if (type == 'alert') {\n        alert(msg);\n      } else if (type == 'throw') {\n        throw new Error(msg);\n      } else if (typeof type == 'function') {\n        type(settings, tn, msg);\n      }\n    } else if (window.console && console.log) {\n      console.log(msg);\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   */\n\n\n  function _fnMap(ret, src, name, mappedName) {\n    if ($.isArray(name)) {\n      $.each(name, function (i, val) {\n        if ($.isArray(val)) {\n          _fnMap(ret, src, val[0], val[1]);\n        } else {\n          _fnMap(ret, src, val);\n        }\n      });\n      return;\n    }\n\n    if (mappedName === undefined) {\n      mappedName = name;\n    }\n\n    if (src[name] !== undefined) {\n      ret[mappedName] = src[name];\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   */\n\n\n  function _fnExtend(out, extender, breakRefs) {\n    var val;\n\n    for (var prop in extender) {\n      if (extender.hasOwnProperty(prop)) {\n        val = extender[prop];\n\n        if ($.isPlainObject(val)) {\n          if (!$.isPlainObject(out[prop])) {\n            out[prop] = {};\n          }\n\n          $.extend(true, out[prop], val);\n        } else if (breakRefs && prop !== 'data' && prop !== 'aaData' && $.isArray(val)) {\n          out[prop] = val.slice();\n        } else {\n          out[prop] = val;\n        }\n      }\n    }\n\n    return out;\n  }\n  /**\n   * Bind an event handers to allow a click or return key to activate the callback.\n   * This is good for accessibility since a return on the keyboard will have the\n   * same effect as a click, if the element has focus.\n   *  @param {element} n Element to bind the action to\n   *  @param {object} oData Data object to pass to the triggered function\n   *  @param {function} fn Callback function for when the event is triggered\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnBindAction(n, oData, fn) {\n    $(n).on('click.DT', oData, function (e) {\n      $(n).blur(); // Remove focus outline for mouse users\n\n      fn(e);\n    }).on('keypress.DT', oData, function (e) {\n      if (e.which === 13) {\n        e.preventDefault();\n        fn(e);\n      }\n    }).on('selectstart.DT', function () {\n      /* Take the brutal approach to cancelling text selection */\n      return false;\n    });\n  }\n  /**\n   * Register a callback function. Easily allows a callback function to be added to\n   * an array store of callback functions that can then all be called together.\n   *  @param {object} oSettings dataTables settings object\n   *  @param {string} sStore Name of the array storage for the callbacks in oSettings\n   *  @param {function} fn Function to be called back\n   *  @param {string} sName Identifying name for the callback (i.e. a label)\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnCallbackReg(oSettings, sStore, fn, sName) {\n    if (fn) {\n      oSettings[sStore].push({\n        \"fn\": fn,\n        \"sName\": sName\n      });\n    }\n  }\n  /**\n   * Fire callback functions and trigger events. Note that the loop over the\n   * callback array store is done backwards! Further note that you do not want to\n   * fire off triggers in time sensitive applications (for example cell creation)\n   * as its slow.\n   *  @param {object} settings dataTables settings object\n   *  @param {string} callbackArr Name of the array storage for the callbacks in\n   *      oSettings\n   *  @param {string} eventName Name of the jQuery custom event to trigger. If\n   *      null no trigger is fired\n   *  @param {array} args Array of arguments to pass to the callback function /\n   *      trigger\n   *  @memberof DataTable#oApi\n   */\n\n\n  function _fnCallbackFire(settings, callbackArr, eventName, args) {\n    var ret = [];\n\n    if (callbackArr) {\n      ret = $.map(settings[callbackArr].slice().reverse(), function (val, i) {\n        return val.fn.apply(settings.oInstance, args);\n      });\n    }\n\n    if (eventName !== null) {\n      var e = $.Event(eventName + '.dt');\n      $(settings.nTable).trigger(e, args);\n      ret.push(e.result);\n    }\n\n    return ret;\n  }\n\n  function _fnLengthOverflow(settings) {\n    var start = settings._iDisplayStart,\n        end = settings.fnDisplayEnd(),\n        len = settings._iDisplayLength;\n    /* If we have space to show extra rows (backing up from the end point - then do so */\n\n    if (start >= end) {\n      start = end - len;\n    } // Keep the start record on the current page\n\n\n    start -= start % len;\n\n    if (len === -1 || start < 0) {\n      start = 0;\n    }\n\n    settings._iDisplayStart = start;\n  }\n\n  function _fnRenderer(settings, type) {\n    var renderer = settings.renderer;\n    var host = DataTable.ext.renderer[type];\n\n    if ($.isPlainObject(renderer) && renderer[type]) {\n      // Specific renderer for this type. If available use it, otherwise use\n      // the default.\n      return host[renderer[type]] || host._;\n    } else if (typeof renderer === 'string') {\n      // Common renderer - if there is one available for this type use it,\n      // otherwise use the default\n      return host[renderer] || host._;\n    } // Use the default\n\n\n    return host._;\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   */\n\n\n  function _fnDataSource(settings) {\n    if (settings.oFeatures.bServerSide) {\n      return 'ssp';\n    } else if (settings.ajax || settings.sAjaxSource) {\n      return 'ajax';\n    }\n\n    return 'dom';\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   */\n\n\n  var __apiStruct = [];\n  /**\n   * `Array.prototype` reference.\n   *\n   * @type object\n   * @ignore\n   */\n\n  var __arrayProto = Array.prototype;\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   */\n\n  var _toSettings = function _toSettings(mixed) {\n    var idx, jq;\n    var settings = DataTable.settings;\n    var tables = $.map(settings, function (el, i) {\n      return el.nTable;\n    });\n\n    if (!mixed) {\n      return [];\n    } else if (mixed.nTable && mixed.oApi) {\n      // DataTables settings object\n      return [mixed];\n    } else if (mixed.nodeName && mixed.nodeName.toLowerCase() === 'table') {\n      // Table node\n      idx = $.inArray(mixed, tables);\n      return idx !== -1 ? [settings[idx]] : null;\n    } else if (mixed && typeof mixed.settings === 'function') {\n      return mixed.settings().toArray();\n    } else if (typeof mixed === 'string') {\n      // jQuery selector\n      jq = $(mixed);\n    } else if (mixed instanceof $) {\n      // jQuery object (also DataTables instance)\n      jq = mixed;\n    }\n\n    if (jq) {\n      return jq.map(function (i) {\n        idx = $.inArray(this, tables);\n        return idx !== -1 ? settings[idx] : null;\n      }).toArray();\n    }\n  };\n  /**\n   * DataTables API class - used to control and interface with  one or more\n   * DataTables enhanced tables.\n   *\n   * The API class is heavily based on jQuery, presenting a chainable interface\n   * that you can use to interact with tables. Each instance of the API class has\n   * a \"context\" - i.e. the tables that it will operate on. This could be a single\n   * table, all tables on a page or a sub-set thereof.\n   *\n   * Additionally the API is designed to allow you to easily work with the data in\n   * the tables, retrieving and manipulating it as required. This is done by\n   * presenting the API class as an array like interface. The contents of the\n   * array depend upon the actions requested by each method (for example\n   * `rows().nodes()` will return an array of nodes, while `rows().data()` will\n   * return an array of objects or arrays depending upon your table's\n   * configuration). The API object has a number of array like methods (`push`,\n   * `pop`, `reverse` etc) as well as additional helper methods (`each`, `pluck`,\n   * `unique` etc) to assist your working with the data held in a table.\n   *\n   * Most methods (those which return an Api instance) are chainable, which means\n   * the return from a method call also has all of the methods available that the\n   * top level object had. For example, these two calls are equivalent:\n   *\n   *     // Not chained\n   *     api.row.add( {...} );\n   *     api.draw();\n   *\n   *     // Chained\n   *     api.row.add( {...} ).draw();\n   *\n   * @class DataTable.Api\n   * @param {array|object|string|jQuery} context DataTable identifier. This is\n   *   used to define which DataTables enhanced tables this API will operate on.\n   *   Can be one of:\n   *\n   *   * `string` - jQuery selector. Any DataTables' matching the given selector\n   *     with be found and used.\n   *   * `node` - `TABLE` node which has already been formed into a DataTable.\n   *   * `jQuery` - A jQuery object of `TABLE` nodes.\n   *   * `object` - DataTables settings object\n   * @param {array} [data] Data to initialise the Api instance with.\n   *\n   * @example\n   *   // Direct initialisation during DataTables construction\n   *   var api = $('#example').DataTable();\n   *\n   * @example\n   *   // Initialisation using a DataTables jQuery object\n   *   var api = $('#example').dataTable().api();\n   *\n   * @example\n   *   // Initialisation as a constructor\n   *   var api = new $.fn.DataTable.Api( 'table.dataTable' );\n   */\n\n\n  _Api2 = function _Api(context, data) {\n    if (!(this instanceof _Api2)) {\n      return new _Api2(context, data);\n    }\n\n    var settings = [];\n\n    var ctxSettings = function ctxSettings(o) {\n      var a = _toSettings(o);\n\n      if (a) {\n        settings = settings.concat(a);\n      }\n    };\n\n    if ($.isArray(context)) {\n      for (var i = 0, ien = context.length; i < ien; i++) {\n        ctxSettings(context[i]);\n      }\n    } else {\n      ctxSettings(context);\n    } // Remove duplicates\n\n\n    this.context = _unique(settings); // Initial data\n\n    if (data) {\n      $.merge(this, data);\n    } // selector\n\n\n    this.selector = {\n      rows: null,\n      cols: null,\n      opts: null\n    };\n\n    _Api2.extend(this, this, __apiStruct);\n  };\n\n  DataTable.Api = _Api2; // Don't destroy the existing prototype, just extend it. Required for jQuery 2's\n  // isPlainObject.\n\n  $.extend(_Api2.prototype, {\n    any: function any() {\n      return this.count() !== 0;\n    },\n    concat: __arrayProto.concat,\n    context: [],\n    // array of table settings objects\n    count: function count() {\n      return this.flatten().length;\n    },\n    each: function each(fn) {\n      for (var i = 0, ien = this.length; i < ien; i++) {\n        fn.call(this, this[i], i, this);\n      }\n\n      return this;\n    },\n    eq: function eq(idx) {\n      var ctx = this.context;\n      return ctx.length > idx ? new _Api2(ctx[idx], this[idx]) : null;\n    },\n    filter: function filter(fn) {\n      var a = [];\n\n      if (__arrayProto.filter) {\n        a = __arrayProto.filter.call(this, fn, this);\n      } else {\n        // Compatibility for browsers without EMCA-252-5 (JS 1.6)\n        for (var i = 0, ien = this.length; i < ien; i++) {\n          if (fn.call(this, this[i], i, this)) {\n            a.push(this[i]);\n          }\n        }\n      }\n\n      return new _Api2(this.context, a);\n    },\n    flatten: function flatten() {\n      var a = [];\n      return new _Api2(this.context, a.concat.apply(a, this.toArray()));\n    },\n    join: __arrayProto.join,\n    indexOf: __arrayProto.indexOf || function (obj, start) {\n      for (var i = start || 0, ien = this.length; i < ien; i++) {\n        if (this[i] === obj) {\n          return i;\n        }\n      }\n\n      return -1;\n    },\n    iterator: function iterator(flatten, type, fn, alwaysNew) {\n      var a = [],\n          ret,\n          i,\n          ien,\n          j,\n          jen,\n          context = this.context,\n          rows,\n          items,\n          item,\n          selector = this.selector; // Argument shifting\n\n      if (typeof flatten === 'string') {\n        alwaysNew = fn;\n        fn = type;\n        type = flatten;\n        flatten = false;\n      }\n\n      for (i = 0, ien = context.length; i < ien; i++) {\n        var apiInst = new _Api2(context[i]);\n\n        if (type === 'table') {\n          ret = fn.call(apiInst, context[i], i);\n\n          if (ret !== undefined) {\n            a.push(ret);\n          }\n        } else if (type === 'columns' || type === 'rows') {\n          // this has same length as context - one entry for each table\n          ret = fn.call(apiInst, context[i], this[i], i);\n\n          if (ret !== undefined) {\n            a.push(ret);\n          }\n        } else if (type === 'column' || type === 'column-rows' || type === 'row' || type === 'cell') {\n          // columns and rows share the same structure.\n          // 'this' is an array of column indexes for each context\n          items = this[i];\n\n          if (type === 'column-rows') {\n            rows = _selector_row_indexes(context[i], selector.opts);\n          }\n\n          for (j = 0, jen = items.length; j < jen; j++) {\n            item = items[j];\n\n            if (type === 'cell') {\n              ret = fn.call(apiInst, context[i], item.row, item.column, i, j);\n            } else {\n              ret = fn.call(apiInst, context[i], item, i, j, rows);\n            }\n\n            if (ret !== undefined) {\n              a.push(ret);\n            }\n          }\n        }\n      }\n\n      if (a.length || alwaysNew) {\n        var api = new _Api2(context, flatten ? a.concat.apply([], a) : a);\n        var apiSelector = api.selector;\n        apiSelector.rows = selector.rows;\n        apiSelector.cols = selector.cols;\n        apiSelector.opts = selector.opts;\n        return api;\n      }\n\n      return this;\n    },\n    lastIndexOf: __arrayProto.lastIndexOf || function (obj, start) {\n      // Bit cheeky...\n      return this.indexOf.apply(this.toArray.reverse(), arguments);\n    },\n    length: 0,\n    map: function map(fn) {\n      var a = [];\n\n      if (__arrayProto.map) {\n        a = __arrayProto.map.call(this, fn, this);\n      } else {\n        // Compatibility for browsers without EMCA-252-5 (JS 1.6)\n        for (var i = 0, ien = this.length; i < ien; i++) {\n          a.push(fn.call(this, this[i], i));\n        }\n      }\n\n      return new _Api2(this.context, a);\n    },\n    pluck: function pluck(prop) {\n      return this.map(function (el) {\n        return el[prop];\n      });\n    },\n    pop: __arrayProto.pop,\n    push: __arrayProto.push,\n    // Does not return an API instance\n    reduce: __arrayProto.reduce || function (fn, init) {\n      return _fnReduce(this, fn, init, 0, this.length, 1);\n    },\n    reduceRight: __arrayProto.reduceRight || function (fn, init) {\n      return _fnReduce(this, fn, init, this.length - 1, -1, -1);\n    },\n    reverse: __arrayProto.reverse,\n    // Object with rows, columns and opts\n    selector: null,\n    shift: __arrayProto.shift,\n    slice: function slice() {\n      return new _Api2(this.context, this);\n    },\n    sort: __arrayProto.sort,\n    // ? name - order?\n    splice: __arrayProto.splice,\n    toArray: function toArray() {\n      return __arrayProto.slice.call(this);\n    },\n    to$: function to$() {\n      return $(this);\n    },\n    toJQuery: function toJQuery() {\n      return $(this);\n    },\n    unique: function unique() {\n      return new _Api2(this.context, _unique(this));\n    },\n    unshift: __arrayProto.unshift\n  });\n\n  _Api2.extend = function (scope, obj, ext) {\n    // Only extend API instances and static properties of the API\n    if (!ext.length || !obj || !(obj instanceof _Api2) && !obj.__dt_wrapper) {\n      return;\n    }\n\n    var i,\n        ien,\n        j,\n        jen,\n        struct,\n        inner,\n        methodScoping = function methodScoping(scope, fn, struc) {\n      return function () {\n        var ret = fn.apply(scope, arguments); // Method extension\n\n        _Api2.extend(ret, ret, struc.methodExt);\n\n        return ret;\n      };\n    };\n\n    for (i = 0, ien = ext.length; i < ien; i++) {\n      struct = ext[i]; // Value\n\n      obj[struct.name] = typeof struct.val === 'function' ? methodScoping(scope, struct.val, struct) : $.isPlainObject(struct.val) ? {} : struct.val;\n      obj[struct.name].__dt_wrapper = true; // Property extension\n\n      _Api2.extend(scope, obj[struct.name], struct.propExt);\n    }\n  }; // @todo - Is there need for an augment function?\n  // _Api.augment = function ( inst, name )\n  // {\n  // \t// Find src object in the structure from the name\n  // \tvar parts = name.split('.');\n  // \t_Api.extend( inst, obj );\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  _Api2.register = _api_register = function _api_register(name, val) {\n    if ($.isArray(name)) {\n      for (var j = 0, jen = name.length; j < jen; j++) {\n        _Api2.register(name[j], val);\n      }\n\n      return;\n    }\n\n    var i,\n        ien,\n        heir = name.split('.'),\n        struct = __apiStruct,\n        key,\n        method;\n\n    var find = function find(src, name) {\n      for (var i = 0, ien = src.length; i < ien; i++) {\n        if (src[i].name === name) {\n          return src[i];\n        }\n      }\n\n      return null;\n    };\n\n    for (i = 0, ien = heir.length; i < ien; i++) {\n      method = heir[i].indexOf('()') !== -1;\n      key = method ? heir[i].replace('()', '') : heir[i];\n      var src = find(struct, key);\n\n      if (!src) {\n        src = {\n          name: key,\n          val: {},\n          methodExt: [],\n          propExt: []\n        };\n        struct.push(src);\n      }\n\n      if (i === ien - 1) {\n        src.val = val;\n      } else {\n        struct = method ? src.methodExt : src.propExt;\n      }\n    }\n  };\n\n  _Api2.registerPlural = _api_registerPlural = function _api_registerPlural(pluralName, singularName, val) {\n    _Api2.register(pluralName, val);\n\n    _Api2.register(singularName, function () {\n      var ret = val.apply(this, arguments);\n\n      if (ret === this) {\n        // Returned item is the API instance that was passed in, return it\n        return this;\n      } else if (ret instanceof _Api2) {\n        // New API instance returned, want the value from the first item\n        // in the returned array for the singular result.\n        return ret.length ? $.isArray(ret[0]) ? new _Api2(ret.context, ret[0]) : // Array results are 'enhanced'\n        ret[0] : undefined;\n      } // Non-API return - just fire it back\n\n\n      return ret;\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   */\n\n\n  var __table_selector = function __table_selector(selector, a) {\n    // Integer is used to pick out a table by index\n    if (typeof selector === 'number') {\n      return [a[selector]];\n    } // Perform a jQuery selector on the table nodes\n\n\n    var nodes = $.map(a, function (el, i) {\n      return el.nTable;\n    });\n    return $(nodes).filter(selector).map(function (i) {\n      // Need to translate back from the table node to the settings\n      var idx = $.inArray(this, nodes);\n      return a[idx];\n    }).toArray();\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\n\n  _api_register('tables()', function (selector) {\n    // A new instance is created if there was a selector specified\n    return selector ? new _Api2(__table_selector(selector, this.context)) : this;\n  });\n\n  _api_register('table()', function (selector) {\n    var tables = this.tables(selector);\n    var ctx = tables.context; // Truncate to the first matched table\n\n    return ctx.length ? new _Api2(ctx[0]) : tables;\n  });\n\n  _api_registerPlural('tables().nodes()', 'table().node()', function () {\n    return this.iterator('table', function (ctx) {\n      return ctx.nTable;\n    }, 1);\n  });\n\n  _api_registerPlural('tables().body()', 'table().body()', function () {\n    return this.iterator('table', function (ctx) {\n      return ctx.nTBody;\n    }, 1);\n  });\n\n  _api_registerPlural('tables().header()', 'table().header()', function () {\n    return this.iterator('table', function (ctx) {\n      return ctx.nTHead;\n    }, 1);\n  });\n\n  _api_registerPlural('tables().footer()', 'table().footer()', function () {\n    return this.iterator('table', function (ctx) {\n      return ctx.nTFoot;\n    }, 1);\n  });\n\n  _api_registerPlural('tables().containers()', 'table().container()', function () {\n    return this.iterator('table', function (ctx) {\n      return ctx.nTableWrapper;\n    }, 1);\n  });\n  /**\n   * Redraw the tables in the current context.\n   */\n\n\n  _api_register('draw()', function (paging) {\n    return this.iterator('table', function (settings) {\n      if (paging === 'page') {\n        _fnDraw(settings);\n      } else {\n        if (typeof paging === 'string') {\n          paging = paging === 'full-hold' ? false : true;\n        }\n\n        _fnReDraw(settings, paging === false);\n      }\n    });\n  });\n  /**\n   * Get the current page index.\n   *\n   * @return {integer} Current page index (zero based)\n   */\n\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\n\n  _api_register('page()', function (action) {\n    if (action === undefined) {\n      return this.page.info().page; // not an expensive call\n    } // else, have an action to take on all tables\n\n\n    return this.iterator('table', function (settings) {\n      _fnPageChange(settings, action);\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\n\n  _api_register('page.info()', function (action) {\n    if (this.context.length === 0) {\n      return undefined;\n    }\n\n    var settings = this.context[0],\n        start = settings._iDisplayStart,\n        len = settings.oFeatures.bPaginate ? settings._iDisplayLength : -1,\n        visRecords = settings.fnRecordsDisplay(),\n        all = len === -1;\n    return {\n      \"page\": all ? 0 : Math.floor(start / len),\n      \"pages\": all ? 1 : Math.ceil(visRecords / len),\n      \"start\": start,\n      \"end\": settings.fnDisplayEnd(),\n      \"length\": len,\n      \"recordsTotal\": settings.fnRecordsTotal(),\n      \"recordsDisplay\": visRecords,\n      \"serverSide\": _fnDataSource(settings) === 'ssp'\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\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\n\n  _api_register('page.len()', function (len) {\n    // Note that we can't call this function 'length()' because `length`\n    // is a Javascript property of functions which defines how many arguments\n    // the function expects.\n    if (len === undefined) {\n      return this.context.length !== 0 ? this.context[0]._iDisplayLength : undefined;\n    } // else, set the page length\n\n\n    return this.iterator('table', function (settings) {\n      _fnLengthChange(settings, len);\n    });\n  });\n\n  var __reload = function __reload(settings, holdPosition, callback) {\n    // Use the draw event to trigger a callback\n    if (callback) {\n      var api = new _Api2(settings);\n      api.one('draw', function () {\n        callback(api.ajax.json());\n      });\n    }\n\n    if (_fnDataSource(settings) == 'ssp') {\n      _fnReDraw(settings, holdPosition);\n    } else {\n      _fnProcessingDisplay(settings, true); // Cancel an existing request\n\n\n      var xhr = settings.jqXHR;\n\n      if (xhr && xhr.readyState !== 4) {\n        xhr.abort();\n      } // Trigger xhr\n\n\n      _fnBuildAjax(settings, [], function (json) {\n        _fnClearTable(settings);\n\n        var data = _fnAjaxDataSrc(settings, json);\n\n        for (var i = 0, ien = data.length; i < ien; i++) {\n          _fnAddData(settings, data[i]);\n        }\n\n        _fnReDraw(settings, holdPosition);\n\n        _fnProcessingDisplay(settings, false);\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\n\n  _api_register('ajax.json()', function () {\n    var ctx = this.context;\n\n    if (ctx.length > 0) {\n      return ctx[0].json;\n    } // else return undefined;\n\n  });\n  /**\n   * Get the data submitted in the last Ajax request\n   */\n\n\n  _api_register('ajax.params()', function () {\n    var ctx = this.context;\n\n    if (ctx.length > 0) {\n      return ctx[0].oAjaxData;\n    } // else return undefined;\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\n\n  _api_register('ajax.reload()', function (callback, resetPaging) {\n    return this.iterator('table', function (settings) {\n      __reload(settings, resetPaging === false, callback);\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\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\n\n  _api_register('ajax.url()', function (url) {\n    var ctx = this.context;\n\n    if (url === undefined) {\n      // get\n      if (ctx.length === 0) {\n        return undefined;\n      }\n\n      ctx = ctx[0];\n      return ctx.ajax ? $.isPlainObject(ctx.ajax) ? ctx.ajax.url : ctx.ajax : ctx.sAjaxSource;\n    } // set\n\n\n    return this.iterator('table', function (settings) {\n      if ($.isPlainObject(settings.ajax)) {\n        settings.ajax.url = url;\n      } else {\n        settings.ajax = url;\n      } // No need to consider sAjaxSource here since DataTables gives priority\n      // to `ajax` over `sAjaxSource`. So setting `ajax` here, renders any\n      // value of `sAjaxSource` redundant.\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\n\n  _api_register('ajax.url().load()', function (callback, resetPaging) {\n    // Same as a reload, but makes sense to present it for easy access after a\n    // url change\n    return this.iterator('table', function (ctx) {\n      __reload(ctx, resetPaging === false, callback);\n    });\n  });\n\n  var _selector_run = function _selector_run(type, selector, selectFn, settings, opts) {\n    var out = [],\n        res,\n        a,\n        i,\n        ien,\n        j,\n        jen,\n        selectorType = typeof selector; // Can't just check for isArray here, as an API or jQuery instance might be\n    // given with their array like look\n\n    if (!selector || selectorType === 'string' || selectorType === 'function' || selector.length === undefined) {\n      selector = [selector];\n    }\n\n    for (i = 0, ien = selector.length; i < ien; i++) {\n      // Only split on simple strings - complex expressions will be jQuery selectors\n      a = selector[i] && selector[i].split && !selector[i].match(/[\\[\\(:]/) ? selector[i].split(',') : [selector[i]];\n\n      for (j = 0, jen = a.length; j < jen; j++) {\n        res = selectFn(typeof a[j] === 'string' ? $.trim(a[j]) : a[j]);\n\n        if (res && res.length) {\n          out = out.concat(res);\n        }\n      }\n    } // selector extensions\n\n\n    var ext = _ext.selector[type];\n\n    if (ext.length) {\n      for (i = 0, ien = ext.length; i < ien; i++) {\n        out = ext[i](settings, opts, out);\n      }\n    }\n\n    return _unique(out);\n  };\n\n  var _selector_opts = function _selector_opts(opts) {\n    if (!opts) {\n      opts = {};\n    } // Backwards compatibility for 1.9- which used the terminology filter rather\n    // than search\n\n\n    if (opts.filter && opts.search === undefined) {\n      opts.search = opts.filter;\n    }\n\n    return $.extend({\n      search: 'none',\n      order: 'current',\n      page: 'all'\n    }, opts);\n  };\n\n  var _selector_first = function _selector_first(inst) {\n    // Reduce the API instance to the first item found\n    for (var i = 0, ien = inst.length; i < ien; i++) {\n      if (inst[i].length > 0) {\n        // Assign the first element to the first item in the instance\n        // and truncate the instance and context\n        inst[0] = inst[i];\n        inst[0].length = 1;\n        inst.length = 1;\n        inst.context = [inst.context[i]];\n        return inst;\n      }\n    } // Not found - return an empty instance\n\n\n    inst.length = 0;\n    return inst;\n  };\n\n  var _selector_row_indexes = function _selector_row_indexes(settings, opts) {\n    var i,\n        ien,\n        tmp,\n        a = [],\n        displayFiltered = settings.aiDisplay,\n        displayMaster = settings.aiDisplayMaster;\n    var search = opts.search,\n        // none, applied, removed\n    order = opts.order,\n        // applied, current, index (original - compatibility with 1.9)\n    page = opts.page; // all, current\n\n    if (_fnDataSource(settings) == 'ssp') {\n      // In server-side processing mode, most options are irrelevant since\n      // rows not shown don't exist and the index order is the applied order\n      // Removed is a special case - for consistency just return an empty\n      // array\n      return search === 'removed' ? [] : _range(0, displayMaster.length);\n    } else if (page == 'current') {\n      // Current page implies that order=current and fitler=applied, since it is\n      // fairly senseless otherwise, regardless of what order and search actually\n      // are\n      for (i = settings._iDisplayStart, ien = settings.fnDisplayEnd(); i < ien; i++) {\n        a.push(displayFiltered[i]);\n      }\n    } else if (order == 'current' || order == 'applied') {\n      if (search == 'none') {\n        a = displayMaster.slice();\n      } else if (search == 'applied') {\n        a = displayFiltered.slice();\n      } else if (search == 'removed') {\n        // O(n+m) solution by creating a hash map\n        var displayFilteredMap = {};\n\n        for (var i = 0, ien = displayFiltered.length; i < ien; i++) {\n          displayFilteredMap[displayFiltered[i]] = null;\n        }\n\n        a = $.map(displayMaster, function (el) {\n          return !displayFilteredMap.hasOwnProperty(el) ? el : null;\n        });\n      }\n    } else if (order == 'index' || order == 'original') {\n      for (i = 0, ien = settings.aoData.length; i < ien; i++) {\n        if (search == 'none') {\n          a.push(i);\n        } else {\n          // applied | removed\n          tmp = $.inArray(i, displayFiltered);\n\n          if (tmp === -1 && search == 'removed' || tmp >= 0 && search == 'applied') {\n            a.push(i);\n          }\n        }\n      }\n    }\n\n    return a;\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   */\n\n\n  var __row_selector = function __row_selector(settings, selector, opts) {\n    var rows;\n\n    var run = function run(sel) {\n      var selInt = _intVal(sel);\n\n      var i, ien;\n      var aoData = settings.aoData; // Short cut - selector is a number and no options provided (default is\n      // all records, so no need to check if the index is in there, since it\n      // must be - dev error if the index doesn't exist).\n\n      if (selInt !== null && !opts) {\n        return [selInt];\n      }\n\n      if (!rows) {\n        rows = _selector_row_indexes(settings, opts);\n      }\n\n      if (selInt !== null && $.inArray(selInt, rows) !== -1) {\n        // Selector - integer\n        return [selInt];\n      } else if (sel === null || sel === undefined || sel === '') {\n        // Selector - none\n        return rows;\n      } // Selector - function\n\n\n      if (typeof sel === 'function') {\n        return $.map(rows, function (idx) {\n          var row = aoData[idx];\n          return sel(idx, row._aData, row.nTr) ? idx : null;\n        });\n      } // Selector - node\n\n\n      if (sel.nodeName) {\n        var rowIdx = sel._DT_RowIndex; // Property added by DT for fast lookup\n\n        var cellIdx = sel._DT_CellIndex;\n\n        if (rowIdx !== undefined) {\n          // Make sure that the row is actually still present in the table\n          return aoData[rowIdx] && aoData[rowIdx].nTr === sel ? [rowIdx] : [];\n        } else if (cellIdx) {\n          return aoData[cellIdx.row] && aoData[cellIdx.row].nTr === sel ? [cellIdx.row] : [];\n        } else {\n          var host = $(sel).closest('*[data-dt-row]');\n          return host.length ? [host.data('dt-row')] : [];\n        }\n      } // ID selector. Want to always be able to select rows by id, regardless\n      // of if the tr element has been created or not, so can't rely upon\n      // jQuery here - hence a custom implementation. This does not match\n      // Sizzle's fast selector or HTML4 - in HTML5 the ID can be anything,\n      // but to select it using a CSS selector engine (like Sizzle or\n      // querySelect) it would need to need to be escaped for some characters.\n      // DataTables simplifies this for row selectors since you can select\n      // only a row. A # indicates an id any anything that follows is the id -\n      // unescaped.\n\n\n      if (typeof sel === 'string' && sel.charAt(0) === '#') {\n        // get row index from id\n        var rowObj = settings.aIds[sel.replace(/^#/, '')];\n\n        if (rowObj !== undefined) {\n          return [rowObj.idx];\n        } // need to fall through to jQuery in case there is DOM id that\n        // matches\n\n      } // Get nodes in the order from the `rows` array with null values removed\n\n\n      var nodes = _removeEmpty(_pluck_order(settings.aoData, rows, 'nTr')); // Selector - jQuery selector string, array of nodes or jQuery object/\n      // As jQuery's .filter() allows jQuery objects to be passed in filter,\n      // it also allows arrays, so this will cope with all three options\n\n\n      return $(nodes).filter(sel).map(function () {\n        return this._DT_RowIndex;\n      }).toArray();\n    };\n\n    return _selector_run('row', selector, run, settings, opts);\n  };\n\n  _api_register('rows()', function (selector, opts) {\n    // argument shifting\n    if (selector === undefined) {\n      selector = '';\n    } else if ($.isPlainObject(selector)) {\n      opts = selector;\n      selector = '';\n    }\n\n    opts = _selector_opts(opts);\n    var inst = this.iterator('table', function (settings) {\n      return __row_selector(settings, selector, opts);\n    }, 1); // Want argument shifting here and in __row_selector?\n\n    inst.selector.rows = selector;\n    inst.selector.opts = opts;\n    return inst;\n  });\n\n  _api_register('rows().nodes()', function () {\n    return this.iterator('row', function (settings, row) {\n      return settings.aoData[row].nTr || undefined;\n    }, 1);\n  });\n\n  _api_register('rows().data()', function () {\n    return this.iterator(true, 'rows', function (settings, rows) {\n      return _pluck_order(settings.aoData, rows, '_aData');\n    }, 1);\n  });\n\n  _api_registerPlural('rows().cache()', 'row().cache()', function (type) {\n    return this.iterator('row', function (settings, row) {\n      var r = settings.aoData[row];\n      return type === 'search' ? r._aFilterData : r._aSortData;\n    }, 1);\n  });\n\n  _api_registerPlural('rows().invalidate()', 'row().invalidate()', function (src) {\n    return this.iterator('row', function (settings, row) {\n      _fnInvalidate(settings, row, src);\n    });\n  });\n\n  _api_registerPlural('rows().indexes()', 'row().index()', function () {\n    return this.iterator('row', function (settings, row) {\n      return row;\n    }, 1);\n  });\n\n  _api_registerPlural('rows().ids()', 'row().id()', function (hash) {\n    var a = [];\n    var context = this.context; // `iterator` will drop undefined values, but in this case we want them\n\n    for (var i = 0, ien = context.length; i < ien; i++) {\n      for (var j = 0, jen = this[i].length; j < jen; j++) {\n        var id = context[i].rowIdFn(context[i].aoData[this[i][j]]._aData);\n        a.push((hash === true ? '#' : '') + id);\n      }\n    }\n\n    return new _Api2(context, a);\n  });\n\n  _api_registerPlural('rows().remove()', 'row().remove()', function () {\n    var that = this;\n    this.iterator('row', function (settings, row, thatIdx) {\n      var data = settings.aoData;\n      var rowData = data[row];\n      var i, ien, j, jen;\n      var loopRow, loopCells;\n      data.splice(row, 1); // Update the cached indexes\n\n      for (i = 0, ien = data.length; i < ien; i++) {\n        loopRow = data[i];\n        loopCells = loopRow.anCells; // Rows\n\n        if (loopRow.nTr !== null) {\n          loopRow.nTr._DT_RowIndex = i;\n        } // Cells\n\n\n        if (loopCells !== null) {\n          for (j = 0, jen = loopCells.length; j < jen; j++) {\n            loopCells[j]._DT_CellIndex.row = i;\n          }\n        }\n      } // Delete from the display arrays\n\n\n      _fnDeleteIndex(settings.aiDisplayMaster, row);\n\n      _fnDeleteIndex(settings.aiDisplay, row);\n\n      _fnDeleteIndex(that[thatIdx], row, false); // maintain local indexes\n      // For server-side processing tables - subtract the deleted row from the count\n\n\n      if (settings._iRecordsDisplay > 0) {\n        settings._iRecordsDisplay--;\n      } // Check for an 'overflow' they case for displaying the table\n\n\n      _fnLengthOverflow(settings); // Remove the row's ID reference if there is one\n\n\n      var id = settings.rowIdFn(rowData._aData);\n\n      if (id !== undefined) {\n        delete settings.aIds[id];\n      }\n    });\n    this.iterator('table', function (settings) {\n      for (var i = 0, ien = settings.aoData.length; i < ien; i++) {\n        settings.aoData[i].idx = i;\n      }\n    });\n    return this;\n  });\n\n  _api_register('rows.add()', function (rows) {\n    var newRows = this.iterator('table', function (settings) {\n      var row, i, ien;\n      var out = [];\n\n      for (i = 0, ien = rows.length; i < ien; i++) {\n        row = rows[i];\n\n        if (row.nodeName && row.nodeName.toUpperCase() === 'TR') {\n          out.push(_fnAddTr(settings, row)[0]);\n        } else {\n          out.push(_fnAddData(settings, row));\n        }\n      }\n\n      return out;\n    }, 1); // Return an Api.rows() extended instance, so rows().nodes() etc can be used\n\n    var modRows = this.rows(-1);\n    modRows.pop();\n    $.merge(modRows, newRows);\n    return modRows;\n  });\n  /**\n   *\n   */\n\n\n  _api_register('row()', function (selector, opts) {\n    return _selector_first(this.rows(selector, opts));\n  });\n\n  _api_register('row().data()', function (data) {\n    var ctx = this.context;\n\n    if (data === undefined) {\n      // Get\n      return ctx.length && this.length ? ctx[0].aoData[this[0]]._aData : undefined;\n    } // Set\n\n\n    var row = ctx[0].aoData[this[0]];\n    row._aData = data; // If the DOM has an id, and the data source is an array\n\n    if ($.isArray(data) && row.nTr.id) {\n      _fnSetObjectDataFn(ctx[0].rowId)(data, row.nTr.id);\n    } // Automatically invalidate\n\n\n    _fnInvalidate(ctx[0], this[0], 'data');\n\n    return this;\n  });\n\n  _api_register('row().node()', function () {\n    var ctx = this.context;\n    return ctx.length && this.length ? ctx[0].aoData[this[0]].nTr || null : null;\n  });\n\n  _api_register('row.add()', function (row) {\n    // Allow a jQuery object to be passed in - only a single row is added from\n    // it though - the first element in the set\n    if (row instanceof $ && row.length) {\n      row = row[0];\n    }\n\n    var rows = this.iterator('table', function (settings) {\n      if (row.nodeName && row.nodeName.toUpperCase() === 'TR') {\n        return _fnAddTr(settings, row)[0];\n      }\n\n      return _fnAddData(settings, row);\n    }); // Return an Api.rows() extended instance, with the newly added row selected\n\n    return this.row(rows[0]);\n  });\n\n  var __details_add = function __details_add(ctx, row, data, klass) {\n    // Convert to array of TR elements\n    var rows = [];\n\n    var addRow = function addRow(r, k) {\n      // Recursion to allow for arrays of jQuery objects\n      if ($.isArray(r) || r instanceof $) {\n        for (var i = 0, ien = r.length; i < ien; i++) {\n          addRow(r[i], k);\n        }\n\n        return;\n      } // If we get a TR element, then just add it directly - up to the dev\n      // to add the correct number of columns etc\n\n\n      if (r.nodeName && r.nodeName.toLowerCase() === 'tr') {\n        rows.push(r);\n      } else {\n        // Otherwise create a row with a wrapper\n        var created = $('<tr><td/></tr>').addClass(k);\n        $('td', created).addClass(k).html(r)[0].colSpan = _fnVisbleColumns(ctx);\n        rows.push(created[0]);\n      }\n    };\n\n    addRow(data, klass);\n\n    if (row._details) {\n      row._details.detach();\n    }\n\n    row._details = $(rows); // If the children were already shown, that state should be retained\n\n    if (row._detailsShow) {\n      row._details.insertAfter(row.nTr);\n    }\n  };\n\n  var __details_remove = function __details_remove(api, idx) {\n    var ctx = api.context;\n\n    if (ctx.length) {\n      var row = ctx[0].aoData[idx !== undefined ? idx : api[0]];\n\n      if (row && row._details) {\n        row._details.remove();\n\n        row._detailsShow = undefined;\n        row._details = undefined;\n      }\n    }\n  };\n\n  var __details_display = function __details_display(api, show) {\n    var ctx = api.context;\n\n    if (ctx.length && api.length) {\n      var row = ctx[0].aoData[api[0]];\n\n      if (row._details) {\n        row._detailsShow = show;\n\n        if (show) {\n          row._details.insertAfter(row.nTr);\n        } else {\n          row._details.detach();\n        }\n\n        __details_events(ctx[0]);\n      }\n    }\n  };\n\n  var __details_events = function __details_events(settings) {\n    var api = new _Api2(settings);\n    var namespace = '.dt.DT_details';\n    var drawEvent = 'draw' + namespace;\n    var colvisEvent = 'column-visibility' + namespace;\n    var destroyEvent = 'destroy' + namespace;\n    var data = settings.aoData;\n    api.off(drawEvent + ' ' + colvisEvent + ' ' + destroyEvent);\n\n    if (_pluck(data, '_details').length > 0) {\n      // On each draw, insert the required elements into the document\n      api.on(drawEvent, function (e, ctx) {\n        if (settings !== ctx) {\n          return;\n        }\n\n        api.rows({\n          page: 'current'\n        }).eq(0).each(function (idx) {\n          // Internal data grab\n          var row = data[idx];\n\n          if (row._detailsShow) {\n            row._details.insertAfter(row.nTr);\n          }\n        });\n      }); // Column visibility change - update the colspan\n\n      api.on(colvisEvent, function (e, ctx, idx, vis) {\n        if (settings !== ctx) {\n          return;\n        } // Update the colspan for the details rows (note, only if it already has\n        // a colspan)\n\n\n        var row,\n            visible = _fnVisbleColumns(ctx);\n\n        for (var i = 0, ien = data.length; i < ien; i++) {\n          row = data[i];\n\n          if (row._details) {\n            row._details.children('td[colspan]').attr('colspan', visible);\n          }\n        }\n      }); // Table destroyed - nuke any child rows\n\n      api.on(destroyEvent, function (e, ctx) {\n        if (settings !== ctx) {\n          return;\n        }\n\n        for (var i = 0, ien = data.length; i < ien; i++) {\n          if (data[i]._details) {\n            __details_remove(api, i);\n          }\n        }\n      });\n    }\n  }; // Strings for the method names to help minification\n\n\n  var _emp = '';\n\n  var _child_obj = _emp + 'row().child';\n\n  var _child_mth = _child_obj + '()'; // data can be:\n  //  tr\n  //  string\n  //  jQuery or array of any of the above\n\n\n  _api_register(_child_mth, function (data, klass) {\n    var ctx = this.context;\n\n    if (data === undefined) {\n      // get\n      return ctx.length && this.length ? ctx[0].aoData[this[0]]._details : undefined;\n    } else if (data === true) {\n      // show\n      this.child.show();\n    } else if (data === false) {\n      // remove\n      __details_remove(this);\n    } else if (ctx.length && this.length) {\n      // set\n      __details_add(ctx[0], ctx[0].aoData[this[0]], data, klass);\n    }\n\n    return this;\n  });\n\n  _api_register([_child_obj + '.show()', _child_mth + '.show()' // only when `child()` was called with parameters (without\n  ], function (show) {\n    // it returns an object and this method is not executed)\n    __details_display(this, true);\n\n    return this;\n  });\n\n  _api_register([_child_obj + '.hide()', _child_mth + '.hide()' // only when `child()` was called with parameters (without\n  ], function () {\n    // it returns an object and this method is not executed)\n    __details_display(this, false);\n\n    return this;\n  });\n\n  _api_register([_child_obj + '.remove()', _child_mth + '.remove()' // only when `child()` was called with parameters (without\n  ], function () {\n    // it returns an object and this method is not executed)\n    __details_remove(this);\n\n    return this;\n  });\n\n  _api_register(_child_obj + '.isShown()', function () {\n    var ctx = this.context;\n\n    if (ctx.length && this.length) {\n      // _detailsShown as false or undefined will fall through to return false\n      return ctx[0].aoData[this[0]]._detailsShow || false;\n    }\n\n    return false;\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  // can be an array of these items, comma separated list, or an array of comma\n  // separated lists\n\n\n  var __re_column_selector = /^([^:]+):(name|visIdx|visible)$/; // r1 and r2 are redundant - but it means that the parameters match for the\n  // iterator callback in columns().data()\n\n  var __columnData = function __columnData(settings, column, r1, r2, rows) {\n    var a = [];\n\n    for (var row = 0, ien = rows.length; row < ien; row++) {\n      a.push(_fnGetCellData(settings, rows[row], column));\n    }\n\n    return a;\n  };\n\n  var __column_selector = function __column_selector(settings, selector, opts) {\n    var columns = settings.aoColumns,\n        names = _pluck(columns, 'sName'),\n        nodes = _pluck(columns, 'nTh');\n\n    var run = function run(s) {\n      var selInt = _intVal(s); // Selector - all\n\n\n      if (s === '') {\n        return _range(columns.length);\n      } // Selector - index\n\n\n      if (selInt !== null) {\n        return [selInt >= 0 ? selInt : // Count from left\n        columns.length + selInt // Count from right (+ because its a negative value)\n        ];\n      } // Selector = function\n\n\n      if (typeof s === 'function') {\n        var rows = _selector_row_indexes(settings, opts);\n\n        return $.map(columns, function (col, idx) {\n          return s(idx, __columnData(settings, idx, 0, 0, rows), nodes[idx]) ? idx : null;\n        });\n      } // jQuery or string selector\n\n\n      var match = typeof s === 'string' ? s.match(__re_column_selector) : '';\n\n      if (match) {\n        switch (match[2]) {\n          case 'visIdx':\n          case 'visible':\n            var idx = parseInt(match[1], 10); // Visible index given, convert to column index\n\n            if (idx < 0) {\n              // Counting from the right\n              var visColumns = $.map(columns, function (col, i) {\n                return col.bVisible ? i : null;\n              });\n              return [visColumns[visColumns.length + idx]];\n            } // Counting from the left\n\n\n            return [_fnVisibleToColumnIndex(settings, idx)];\n\n          case 'name':\n            // match by name. `names` is column index complete and in order\n            return $.map(names, function (name, i) {\n              return name === match[1] ? i : null;\n            });\n\n          default:\n            return [];\n        }\n      } // Cell in the table body\n\n\n      if (s.nodeName && s._DT_CellIndex) {\n        return [s._DT_CellIndex.column];\n      } // jQuery selector on the TH elements for the columns\n\n\n      var jqResult = $(nodes).filter(s).map(function () {\n        return $.inArray(this, nodes); // `nodes` is column index complete and in order\n      }).toArray();\n\n      if (jqResult.length || !s.nodeName) {\n        return jqResult;\n      } // Otherwise a node which might have a `dt-column` data attribute, or be\n      // a child or such an element\n\n\n      var host = $(s).closest('*[data-dt-column]');\n      return host.length ? [host.data('dt-column')] : [];\n    };\n\n    return _selector_run('column', selector, run, settings, opts);\n  };\n\n  var __setColumnVis = function __setColumnVis(settings, column, vis) {\n    var cols = settings.aoColumns,\n        col = cols[column],\n        data = settings.aoData,\n        row,\n        cells,\n        i,\n        ien,\n        tr; // Get\n\n    if (vis === undefined) {\n      return col.bVisible;\n    } // Set\n    // No change\n\n\n    if (col.bVisible === vis) {\n      return;\n    }\n\n    if (vis) {\n      // Insert column\n      // Need to decide if we should use appendChild or insertBefore\n      var insertBefore = $.inArray(true, _pluck(cols, 'bVisible'), column + 1);\n\n      for (i = 0, ien = data.length; i < ien; i++) {\n        tr = data[i].nTr;\n        cells = data[i].anCells;\n\n        if (tr) {\n          // insertBefore can act like appendChild if 2nd arg is null\n          tr.insertBefore(cells[column], cells[insertBefore] || null);\n        }\n      }\n    } else {\n      // Remove column\n      $(_pluck(settings.aoData, 'anCells', column)).detach();\n    } // Common actions\n\n\n    col.bVisible = vis;\n\n    _fnDrawHead(settings, settings.aoHeader);\n\n    _fnDrawHead(settings, settings.aoFooter); // Update colspan for no records display. Child rows and extensions will use their own\n    // listeners to do this - only need to update the empty table item here\n\n\n    if (!settings.aiDisplay.length) {\n      $(settings.nTBody).find('td[colspan]').attr('colspan', _fnVisbleColumns(settings));\n    }\n\n    _fnSaveState(settings);\n  };\n\n  _api_register('columns()', function (selector, opts) {\n    // argument shifting\n    if (selector === undefined) {\n      selector = '';\n    } else if ($.isPlainObject(selector)) {\n      opts = selector;\n      selector = '';\n    }\n\n    opts = _selector_opts(opts);\n    var inst = this.iterator('table', function (settings) {\n      return __column_selector(settings, selector, opts);\n    }, 1); // Want argument shifting here and in _row_selector?\n\n    inst.selector.cols = selector;\n    inst.selector.opts = opts;\n    return inst;\n  });\n\n  _api_registerPlural('columns().header()', 'column().header()', function (selector, opts) {\n    return this.iterator('column', function (settings, column) {\n      return settings.aoColumns[column].nTh;\n    }, 1);\n  });\n\n  _api_registerPlural('columns().footer()', 'column().footer()', function (selector, opts) {\n    return this.iterator('column', function (settings, column) {\n      return settings.aoColumns[column].nTf;\n    }, 1);\n  });\n\n  _api_registerPlural('columns().data()', 'column().data()', function () {\n    return this.iterator('column-rows', __columnData, 1);\n  });\n\n  _api_registerPlural('columns().dataSrc()', 'column().dataSrc()', function () {\n    return this.iterator('column', function (settings, column) {\n      return settings.aoColumns[column].mData;\n    }, 1);\n  });\n\n  _api_registerPlural('columns().cache()', 'column().cache()', function (type) {\n    return this.iterator('column-rows', function (settings, column, i, j, rows) {\n      return _pluck_order(settings.aoData, rows, type === 'search' ? '_aFilterData' : '_aSortData', column);\n    }, 1);\n  });\n\n  _api_registerPlural('columns().nodes()', 'column().nodes()', function () {\n    return this.iterator('column-rows', function (settings, column, i, j, rows) {\n      return _pluck_order(settings.aoData, rows, 'anCells', column);\n    }, 1);\n  });\n\n  _api_registerPlural('columns().visible()', 'column().visible()', function (vis, calc) {\n    var ret = this.iterator('column', function (settings, column) {\n      if (vis === undefined) {\n        return settings.aoColumns[column].bVisible;\n      } // else\n\n\n      __setColumnVis(settings, column, vis);\n    }); // Group the column visibility changes\n\n    if (vis !== undefined) {\n      // Second loop once the first is done for events\n      this.iterator('column', function (settings, column) {\n        _fnCallbackFire(settings, null, 'column-visibility', [settings, column, vis, calc]);\n      });\n\n      if (calc === undefined || calc) {\n        this.columns.adjust();\n      }\n    }\n\n    return ret;\n  });\n\n  _api_registerPlural('columns().indexes()', 'column().index()', function (type) {\n    return this.iterator('column', function (settings, column) {\n      return type === 'visible' ? _fnColumnIndexToVisible(settings, column) : column;\n    }, 1);\n  });\n\n  _api_register('columns.adjust()', function () {\n    return this.iterator('table', function (settings) {\n      _fnAdjustColumnSizing(settings);\n    }, 1);\n  });\n\n  _api_register('column.index()', function (type, idx) {\n    if (this.context.length !== 0) {\n      var ctx = this.context[0];\n\n      if (type === 'fromVisible' || type === 'toData') {\n        return _fnVisibleToColumnIndex(ctx, idx);\n      } else if (type === 'fromData' || type === 'toVisible') {\n        return _fnColumnIndexToVisible(ctx, idx);\n      }\n    }\n  });\n\n  _api_register('column()', function (selector, opts) {\n    return _selector_first(this.columns(selector, opts));\n  });\n\n  var __cell_selector = function __cell_selector(settings, selector, opts) {\n    var data = settings.aoData;\n\n    var rows = _selector_row_indexes(settings, opts);\n\n    var cells = _removeEmpty(_pluck_order(data, rows, 'anCells'));\n\n    var allCells = $([].concat.apply([], cells));\n    var row;\n    var columns = settings.aoColumns.length;\n    var a, i, ien, j, o, host;\n\n    var run = function run(s) {\n      var fnSelector = typeof s === 'function';\n\n      if (s === null || s === undefined || fnSelector) {\n        // All cells and function selectors\n        a = [];\n\n        for (i = 0, ien = rows.length; i < ien; i++) {\n          row = rows[i];\n\n          for (j = 0; j < columns; j++) {\n            o = {\n              row: row,\n              column: j\n            };\n\n            if (fnSelector) {\n              // Selector - function\n              host = data[row];\n\n              if (s(o, _fnGetCellData(settings, row, j), host.anCells ? host.anCells[j] : null)) {\n                a.push(o);\n              }\n            } else {\n              // Selector - all\n              a.push(o);\n            }\n          }\n        }\n\n        return a;\n      } // Selector - index\n\n\n      if ($.isPlainObject(s)) {\n        // Valid cell index and its in the array of selectable rows\n        return s.column !== undefined && s.row !== undefined && $.inArray(s.row, rows) !== -1 ? [s] : [];\n      } // Selector - jQuery filtered cells\n\n\n      var jqResult = allCells.filter(s).map(function (i, el) {\n        return {\n          // use a new object, in case someone changes the values\n          row: el._DT_CellIndex.row,\n          column: el._DT_CellIndex.column\n        };\n      }).toArray();\n\n      if (jqResult.length || !s.nodeName) {\n        return jqResult;\n      } // Otherwise the selector is a node, and there is one last option - the\n      // element might be a child of an element which has dt-row and dt-column\n      // data attributes\n\n\n      host = $(s).closest('*[data-dt-row]');\n      return host.length ? [{\n        row: host.data('dt-row'),\n        column: host.data('dt-column')\n      }] : [];\n    };\n\n    return _selector_run('cell', selector, run, settings, opts);\n  };\n\n  _api_register('cells()', function (rowSelector, columnSelector, opts) {\n    // Argument shifting\n    if ($.isPlainObject(rowSelector)) {\n      // Indexes\n      if (rowSelector.row === undefined) {\n        // Selector options in first parameter\n        opts = rowSelector;\n        rowSelector = null;\n      } else {\n        // Cell index objects in first parameter\n        opts = columnSelector;\n        columnSelector = null;\n      }\n    }\n\n    if ($.isPlainObject(columnSelector)) {\n      opts = columnSelector;\n      columnSelector = null;\n    } // Cell selector\n\n\n    if (columnSelector === null || columnSelector === undefined) {\n      return this.iterator('table', function (settings) {\n        return __cell_selector(settings, rowSelector, _selector_opts(opts));\n      });\n    } // Row + column selector\n\n\n    var columns = this.columns(columnSelector);\n    var rows = this.rows(rowSelector);\n    var a, i, ien, j, jen;\n    this.iterator('table', function (settings, idx) {\n      a = [];\n\n      for (i = 0, ien = rows[idx].length; i < ien; i++) {\n        for (j = 0, jen = columns[idx].length; j < jen; j++) {\n          a.push({\n            row: rows[idx][i],\n            column: columns[idx][j]\n          });\n        }\n      }\n    }, 1); // Now pass through the cell selector for options\n\n    var cells = this.cells(a, opts);\n    $.extend(cells.selector, {\n      cols: columnSelector,\n      rows: rowSelector,\n      opts: opts\n    });\n    return cells;\n  });\n\n  _api_registerPlural('cells().nodes()', 'cell().node()', function () {\n    return this.iterator('cell', function (settings, row, column) {\n      var data = settings.aoData[row];\n      return data && data.anCells ? data.anCells[column] : undefined;\n    }, 1);\n  });\n\n  _api_register('cells().data()', function () {\n    return this.iterator('cell', function (settings, row, column) {\n      return _fnGetCellData(settings, row, column);\n    }, 1);\n  });\n\n  _api_registerPlural('cells().cache()', 'cell().cache()', function (type) {\n    type = type === 'search' ? '_aFilterData' : '_aSortData';\n    return this.iterator('cell', function (settings, row, column) {\n      return settings.aoData[row][type][column];\n    }, 1);\n  });\n\n  _api_registerPlural('cells().render()', 'cell().render()', function (type) {\n    return this.iterator('cell', function (settings, row, column) {\n      return _fnGetCellData(settings, row, column, type);\n    }, 1);\n  });\n\n  _api_registerPlural('cells().indexes()', 'cell().index()', function () {\n    return this.iterator('cell', function (settings, row, column) {\n      return {\n        row: row,\n        column: column,\n        columnVisible: _fnColumnIndexToVisible(settings, column)\n      };\n    }, 1);\n  });\n\n  _api_registerPlural('cells().invalidate()', 'cell().invalidate()', function (src) {\n    return this.iterator('cell', function (settings, row, column) {\n      _fnInvalidate(settings, row, src, column);\n    });\n  });\n\n  _api_register('cell()', function (rowSelector, columnSelector, opts) {\n    return _selector_first(this.cells(rowSelector, columnSelector, opts));\n  });\n\n  _api_register('cell().data()', function (data) {\n    var ctx = this.context;\n    var cell = this[0];\n\n    if (data === undefined) {\n      // Get\n      return ctx.length && cell.length ? _fnGetCellData(ctx[0], cell[0].row, cell[0].column) : undefined;\n    } // Set\n\n\n    _fnSetCellData(ctx[0], cell[0].row, cell[0].column, data);\n\n    _fnInvalidate(ctx[0], cell[0].row, 'data', cell[0].column);\n\n    return this;\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\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\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\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\n\n  _api_register('order()', function (order, dir) {\n    var ctx = this.context;\n\n    if (order === undefined) {\n      // get\n      return ctx.length !== 0 ? ctx[0].aaSorting : undefined;\n    } // set\n\n\n    if (typeof order === 'number') {\n      // Simple column / direction passed in\n      order = [[order, dir]];\n    } else if (order.length && !$.isArray(order[0])) {\n      // Arguments passed in (list of 1D arrays)\n      order = Array.prototype.slice.call(arguments);\n    } // otherwise a 2D array was passed in\n\n\n    return this.iterator('table', function (settings) {\n      settings.aaSorting = order.slice();\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\n\n  _api_register('order.listener()', function (node, column, callback) {\n    return this.iterator('table', function (settings) {\n      _fnSortAttachListener(settings, node, column, callback);\n    });\n  });\n\n  _api_register('order.fixed()', function (set) {\n    if (!set) {\n      var ctx = this.context;\n      var fixed = ctx.length ? ctx[0].aaSortingFixed : undefined;\n      return $.isArray(fixed) ? {\n        pre: fixed\n      } : fixed;\n    }\n\n    return this.iterator('table', function (settings) {\n      settings.aaSortingFixed = $.extend(true, {}, set);\n    });\n  }); // Order by the selected column(s)\n\n\n  _api_register(['columns().order()', 'column().order()'], function (dir) {\n    var that = this;\n    return this.iterator('table', function (settings, i) {\n      var sort = [];\n      $.each(that[i], function (j, col) {\n        sort.push([col, dir]);\n      });\n      settings.aaSorting = sort;\n    });\n  });\n\n  _api_register('search()', function (input, regex, smart, caseInsen) {\n    var ctx = this.context;\n\n    if (input === undefined) {\n      // get\n      return ctx.length !== 0 ? ctx[0].oPreviousSearch.sSearch : undefined;\n    } // set\n\n\n    return this.iterator('table', function (settings) {\n      if (!settings.oFeatures.bFilter) {\n        return;\n      }\n\n      _fnFilterComplete(settings, $.extend({}, settings.oPreviousSearch, {\n        \"sSearch\": input + \"\",\n        \"bRegex\": regex === null ? false : regex,\n        \"bSmart\": smart === null ? true : smart,\n        \"bCaseInsensitive\": caseInsen === null ? true : caseInsen\n      }), 1);\n    });\n  });\n\n  _api_registerPlural('columns().search()', 'column().search()', function (input, regex, smart, caseInsen) {\n    return this.iterator('column', function (settings, column) {\n      var preSearch = settings.aoPreSearchCols;\n\n      if (input === undefined) {\n        // get\n        return preSearch[column].sSearch;\n      } // set\n\n\n      if (!settings.oFeatures.bFilter) {\n        return;\n      }\n\n      $.extend(preSearch[column], {\n        \"sSearch\": input + \"\",\n        \"bRegex\": regex === null ? false : regex,\n        \"bSmart\": smart === null ? true : smart,\n        \"bCaseInsensitive\": caseInsen === null ? true : caseInsen\n      });\n\n      _fnFilterComplete(settings, settings.oPreviousSearch, 1);\n    });\n  });\n  /*\n   * State API methods\n   */\n\n\n  _api_register('state()', function () {\n    return this.context.length ? this.context[0].oSavedState : null;\n  });\n\n  _api_register('state.clear()', function () {\n    return this.iterator('table', function (settings) {\n      // Save an empty object\n      settings.fnStateSaveCallback.call(settings.oInstance, settings, {});\n    });\n  });\n\n  _api_register('state.loaded()', function () {\n    return this.context.length ? this.context[0].oLoadedState : null;\n  });\n\n  _api_register('state.save()', function () {\n    return this.iterator('table', function (settings) {\n      _fnSaveState(settings);\n    });\n  });\n  /**\n   * Provide a common method for plug-ins to check the version of DataTables being\n   * used, in order to ensure compatibility.\n   *\n   *  @param {string} version Version string to check for, in the format \"X.Y.Z\".\n   *    Note that the formats \"X\" and \"X.Y\" are also acceptable.\n   *  @returns {boolean} true if this version of DataTables is greater or equal to\n   *    the required version, or false if this version of DataTales is not\n   *    suitable\n   *  @static\n   *  @dtopt API-Static\n   *\n   *  @example\n   *    alert( $.fn.dataTable.versionCheck( '1.9.0' ) );\n   */\n\n\n  DataTable.versionCheck = DataTable.fnVersionCheck = function (version) {\n    var aThis = DataTable.version.split('.');\n    var aThat = version.split('.');\n    var iThis, iThat;\n\n    for (var i = 0, iLen = aThat.length; i < iLen; i++) {\n      iThis = parseInt(aThis[i], 10) || 0;\n      iThat = parseInt(aThat[i], 10) || 0; // Parts are the same, keep comparing\n\n      if (iThis === iThat) {\n        continue;\n      } // Parts are different, return immediately\n\n\n      return iThis > iThat;\n    }\n\n    return true;\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   */\n\n\n  DataTable.isDataTable = DataTable.fnIsDataTable = function (table) {\n    var t = $(table).get(0);\n    var is = false;\n\n    if (table instanceof DataTable.Api) {\n      return true;\n    }\n\n    $.each(DataTable.settings, function (i, o) {\n      var head = o.nScrollHead ? $('table', o.nScrollHead)[0] : null;\n      var foot = o.nScrollFoot ? $('table', o.nScrollFoot)[0] : null;\n\n      if (o.nTable === t || head === t || foot === t) {\n        is = true;\n      }\n    });\n    return is;\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   */\n\n\n  DataTable.tables = DataTable.fnTables = function (visible) {\n    var api = false;\n\n    if ($.isPlainObject(visible)) {\n      api = visible.api;\n      visible = visible.visible;\n    }\n\n    var a = $.map(DataTable.settings, function (o) {\n      if (!visible || visible && $(o.nTable).is(':visible')) {\n        return o.nTable;\n      }\n    });\n    return api ? new _Api2(a) : a;\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   */\n\n\n  DataTable.camelToHungarian = _fnCamelToHungarian;\n  /**\n   *\n   */\n\n  _api_register('$()', function (selector, opts) {\n    var rows = this.rows(opts).nodes(),\n        // Get all rows\n    jqRows = $(rows);\n    return $([].concat(jqRows.filter(selector).toArray(), jqRows.find(selector).toArray()));\n  }); // jQuery functions to operate on the tables\n\n\n  $.each(['on', 'one', 'off'], function (i, key) {\n    _api_register(key + '()', function ()\n    /* event, handler */\n    {\n      var args = Array.prototype.slice.call(arguments); // Add the `dt` namespace automatically if it isn't already present\n\n      args[0] = $.map(args[0].split(/\\s/), function (e) {\n        return !e.match(/\\.dt\\b/) ? e + '.dt' : e;\n      }).join(' ');\n      var inst = $(this.tables().nodes());\n      inst[key].apply(inst, args);\n      return this;\n    });\n  });\n\n  _api_register('clear()', function () {\n    return this.iterator('table', function (settings) {\n      _fnClearTable(settings);\n    });\n  });\n\n  _api_register('settings()', function () {\n    return new _Api2(this.context, this.context);\n  });\n\n  _api_register('init()', function () {\n    var ctx = this.context;\n    return ctx.length ? ctx[0].oInit : null;\n  });\n\n  _api_register('data()', function () {\n    return this.iterator('table', function (settings) {\n      return _pluck(settings.aoData, '_aData');\n    }).flatten();\n  });\n\n  _api_register('destroy()', function (remove) {\n    remove = remove || false;\n    return this.iterator('table', function (settings) {\n      var orig = settings.nTableWrapper.parentNode;\n      var classes = settings.oClasses;\n      var table = settings.nTable;\n      var tbody = settings.nTBody;\n      var thead = settings.nTHead;\n      var tfoot = settings.nTFoot;\n      var jqTable = $(table);\n      var jqTbody = $(tbody);\n      var jqWrapper = $(settings.nTableWrapper);\n      var rows = $.map(settings.aoData, function (r) {\n        return r.nTr;\n      });\n      var i, ien; // Flag to note that the table is currently being destroyed - no action\n      // should be taken\n\n      settings.bDestroying = true; // Fire off the destroy callbacks for plug-ins etc\n\n      _fnCallbackFire(settings, \"aoDestroyCallback\", \"destroy\", [settings]); // If not being removed from the document, make all columns visible\n\n\n      if (!remove) {\n        new _Api2(settings).columns().visible(true);\n      } // Blitz all `DT` namespaced events (these are internal events, the\n      // lowercase, `dt` events are user subscribed and they are responsible\n      // for removing them\n\n\n      jqWrapper.off('.DT').find(':not(tbody *)').off('.DT');\n      $(window).off('.DT-' + settings.sInstance); // When scrolling we had to break the table up - restore it\n\n      if (table != thead.parentNode) {\n        jqTable.children('thead').detach();\n        jqTable.append(thead);\n      }\n\n      if (tfoot && table != tfoot.parentNode) {\n        jqTable.children('tfoot').detach();\n        jqTable.append(tfoot);\n      }\n\n      settings.aaSorting = [];\n      settings.aaSortingFixed = [];\n\n      _fnSortingClasses(settings);\n\n      $(rows).removeClass(settings.asStripeClasses.join(' '));\n      $('th, td', thead).removeClass(classes.sSortable + ' ' + classes.sSortableAsc + ' ' + classes.sSortableDesc + ' ' + classes.sSortableNone); // Add the TR elements back into the table in their original order\n\n      jqTbody.children().detach();\n      jqTbody.append(rows); // Remove the DataTables generated nodes, events and classes\n\n      var removedMethod = remove ? 'remove' : 'detach';\n      jqTable[removedMethod]();\n      jqWrapper[removedMethod](); // If we need to reattach the table to the document\n\n      if (!remove && orig) {\n        // insertBefore acts like appendChild if !arg[1]\n        orig.insertBefore(table, settings.nTableReinsertBefore); // Restore the width of the original table - was read from the style property,\n        // so we can restore directly to that\n\n        jqTable.css('width', settings.sDestroyWidth).removeClass(classes.sTable); // If the were originally stripe classes - then we add them back here.\n        // Note this is not fool proof (for example if not all rows had stripe\n        // classes - but it's a good effort without getting carried away\n\n        ien = settings.asDestroyStripes.length;\n\n        if (ien) {\n          jqTbody.children().each(function (i) {\n            $(this).addClass(settings.asDestroyStripes[i % ien]);\n          });\n        }\n      }\n      /* Remove the settings object from the settings array */\n\n\n      var idx = $.inArray(settings, DataTable.settings);\n\n      if (idx !== -1) {\n        DataTable.settings.splice(idx, 1);\n      }\n    });\n  }); // Add the `every()` method for rows, columns and cells in a compact form\n\n\n  $.each(['column', 'row', 'cell'], function (i, type) {\n    _api_register(type + 's().every()', function (fn) {\n      var opts = this.selector.opts;\n      var api = this;\n      return this.iterator(type, function (settings, arg1, arg2, arg3, arg4) {\n        // Rows and columns:\n        //  arg1 - index\n        //  arg2 - table counter\n        //  arg3 - loop counter\n        //  arg4 - undefined\n        // Cells:\n        //  arg1 - row index\n        //  arg2 - column index\n        //  arg3 - table counter\n        //  arg4 - loop counter\n        fn.call(api[type](arg1, type === 'cell' ? arg2 : opts, type === 'cell' ? opts : undefined), arg1, arg2, arg3, arg4);\n      });\n    });\n  }); // i18n method for extensions to be able to use the language object from the\n  // DataTable\n\n  _api_register('i18n()', function (token, def, plural) {\n    var ctx = this.context[0];\n\n    var resolved = _fnGetObjectDataFn(token)(ctx.oLanguage);\n\n    if (resolved === undefined) {\n      resolved = def;\n    }\n\n    if (plural !== undefined && $.isPlainObject(resolved)) {\n      resolved = resolved[plural] !== undefined ? resolved[plural] : resolved._;\n    }\n\n    return resolved.replace('%d', plural); // nb: plural might be undefined,\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 http://semver.org/ for more information.\n   *  @member\n   *  @type string\n   *  @default Version number\n   */\n\n\n  DataTable.version = \"1.10.19\";\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   */\n\n  DataTable.settings = [];\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   */\n\n  DataTable.models = {};\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   */\n\n  DataTable.models.oSearch = {\n    /**\n     * Flag to indicate if the filtering should be case insensitive or not\n     *  @type boolean\n     *  @default true\n     */\n    \"bCaseInsensitive\": true,\n\n    /**\n     * Applied search term\n     *  @type string\n     *  @default <i>Empty string</i>\n     */\n    \"sSearch\": \"\",\n\n    /**\n     * Flag to indicate if the search term should be interpreted as a\n     * regular expression (true) or not (false) and therefore and special\n     * regex characters escaped.\n     *  @type boolean\n     *  @default false\n     */\n    \"bRegex\": false,\n\n    /**\n     * Flag to indicate if DataTables is to use its smart filtering or not.\n     *  @type boolean\n     *  @default true\n     */\n    \"bSmart\": true\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   */\n\n  DataTable.models.oRow = {\n    /**\n     * TR element for the row\n     *  @type node\n     *  @default null\n     */\n    \"nTr\": null,\n\n    /**\n     * Array of TD elements for each row. This is null until the row has been\n     * created.\n     *  @type array nodes\n     *  @default []\n     */\n    \"anCells\": null,\n\n    /**\n     * Data object from the original data source for the row. This is either\n     * an array if using the traditional form of DataTables, or an object if\n     * using mData options. The exact type will depend on the passed in\n     * data from the data source, or will be an array if using DOM a data\n     * source.\n     *  @type array|object\n     *  @default []\n     */\n    \"_aData\": [],\n\n    /**\n     * Sorting data cache - this array is ostensibly the same length as the\n     * number of columns (although each index is generated only as it is\n     * needed), and holds the data that is used for sorting each column in the\n     * row. We do this cache generation at the start of the sort in order that\n     * the formatting of the sort data need be done only once for each cell\n     * per sort. This array should not be read from or written to by anything\n     * other than the master sorting methods.\n     *  @type array\n     *  @default null\n     *  @private\n     */\n    \"_aSortData\": null,\n\n    /**\n     * Per cell filtering data cache. As per the sort data cache, used to\n     * increase the performance of the filtering in DataTables\n     *  @type array\n     *  @default null\n     *  @private\n     */\n    \"_aFilterData\": null,\n\n    /**\n     * Filtering data cache. This is the same as the cell filtering cache, but\n     * in this case a string rather than an array. This is easily computed with\n     * a join on `_aFilterData`, but is provided as a cache so the join isn't\n     * needed on every search (memory traded for performance)\n     *  @type array\n     *  @default null\n     *  @private\n     */\n    \"_sFilterRow\": null,\n\n    /**\n     * Cache of the class name that DataTables has applied to the row, so we\n     * can quickly look at this variable rather than needing to do a DOM check\n     * on className for the nTr property.\n     *  @type string\n     *  @default <i>Empty string</i>\n     *  @private\n     */\n    \"_sRowStripe\": \"\",\n\n    /**\n     * Denote if the original data source was from the DOM, or the data source\n     * object. This is used for invalidating data, so DataTables can\n     * automatically read data from the original source, unless uninstructed\n     * otherwise.\n     *  @type string\n     *  @default null\n     *  @private\n     */\n    \"src\": null,\n\n    /**\n     * Index in the aoData array. This saves an indexOf lookup when we have the\n     * object, but want to know the index\n     *  @type integer\n     *  @default -1\n     *  @private\n     */\n    \"idx\": -1\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   */\n\n  DataTable.models.oColumn = {\n    /**\n     * Column index. This could be worked out on-the-fly with $.inArray, but it\n     * is faster to just hold it as a variable\n     *  @type integer\n     *  @default null\n     */\n    \"idx\": null,\n\n    /**\n     * A list of the columns that sorting should occur on when this column\n     * is sorted. That this property is an array allows multi-column sorting\n     * to be defined for a column (for example first name / last name columns\n     * would benefit from this). The values are integers pointing to the\n     * columns to be sorted on (typically it will be a single integer pointing\n     * at itself, but that doesn't need to be the case).\n     *  @type array\n     */\n    \"aDataSort\": null,\n\n    /**\n     * Define the sorting directions that are applied to the column, in sequence\n     * as the column is repeatedly sorted upon - i.e. the first value is used\n     * as the sorting direction when the column if first sorted (clicked on).\n     * Sort it again (click again) and it will move on to the next index.\n     * Repeat until loop.\n     *  @type array\n     */\n    \"asSorting\": null,\n\n    /**\n     * Flag to indicate if the column is searchable, and thus should be included\n     * in the filtering or not.\n     *  @type boolean\n     */\n    \"bSearchable\": null,\n\n    /**\n     * Flag to indicate if the column is sortable or not.\n     *  @type boolean\n     */\n    \"bSortable\": null,\n\n    /**\n     * Flag to indicate if the column is currently visible in the table or not\n     *  @type boolean\n     */\n    \"bVisible\": null,\n\n    /**\n     * Store for manual type assignment using the `column.type` option. This\n     * is held in store so we can manipulate the column's `sType` property.\n     *  @type string\n     *  @default null\n     *  @private\n     */\n    \"_sManualType\": null,\n\n    /**\n     * Flag to indicate if HTML5 data attributes should be used as the data\n     * source for filtering or sorting. True is either are.\n     *  @type boolean\n     *  @default false\n     *  @private\n     */\n    \"_bAttrSrc\": false,\n\n    /**\n     * Developer definable function that is called whenever a cell is created (Ajax source,\n     * etc) or processed for input (DOM source). This can be used as a compliment to mRender\n     * allowing you to modify the DOM element (add background colour for example) when the\n     * element is available.\n     *  @type function\n     *  @param {element} nTd The TD node that has been created\n     *  @param {*} sData The Data for the cell\n     *  @param {array|object} oData The data for the whole row\n     *  @param {int} iRow The row index for the aoData data store\n     *  @default null\n     */\n    \"fnCreatedCell\": null,\n\n    /**\n     * Function to get data from a cell in a column. You should <b>never</b>\n     * access data directly through _aData internally in DataTables - always use\n     * the method attached to this property. It allows mData to function as\n     * required. This function is automatically assigned by the column\n     * initialisation method\n     *  @type function\n     *  @param {array|object} oData The data array/object for the array\n     *    (i.e. aoData[]._aData)\n     *  @param {string} sSpecific The specific data type you want to get -\n     *    'display', 'type' 'filter' 'sort'\n     *  @returns {*} The data for the cell from the given row's data\n     *  @default null\n     */\n    \"fnGetData\": null,\n\n    /**\n     * Function to set data for a cell in the column. You should <b>never</b>\n     * set the data directly to _aData internally in DataTables - always use\n     * this method. It allows mData to function as required. This function\n     * is automatically assigned by the column initialisation method\n     *  @type function\n     *  @param {array|object} oData The data array/object for the array\n     *    (i.e. aoData[]._aData)\n     *  @param {*} sValue Value to set\n     *  @default null\n     */\n    \"fnSetData\": null,\n\n    /**\n     * Property to read the value for the cells in the column from the data\n     * source array / object. If null, then the default content is used, if a\n     * function is given then the return from the function is used.\n     *  @type function|int|string|null\n     *  @default null\n     */\n    \"mData\": null,\n\n    /**\n     * Partner property to mData which is used (only when defined) to get\n     * the data - i.e. it is basically the same as mData, but without the\n     * 'set' option, and also the data fed to it is the result from mData.\n     * This is the rendering method to match the data method of mData.\n     *  @type function|int|string|null\n     *  @default null\n     */\n    \"mRender\": null,\n\n    /**\n     * Unique header TH/TD element for this column - this is what the sorting\n     * listener is attached to (if sorting is enabled.)\n     *  @type node\n     *  @default null\n     */\n    \"nTh\": null,\n\n    /**\n     * Unique footer TH/TD element for this column (if there is one). Not used\n     * in DataTables as such, but can be used for plug-ins to reference the\n     * footer for each column.\n     *  @type node\n     *  @default null\n     */\n    \"nTf\": null,\n\n    /**\n     * The class to apply to all TD elements in the table's TBODY for the column\n     *  @type string\n     *  @default null\n     */\n    \"sClass\": null,\n\n    /**\n     * When DataTables calculates the column widths to assign to each column,\n     * it finds the longest string in each column and then constructs a\n     * temporary table and reads the widths from that. The problem with this\n     * is that \"mmm\" is much wider then \"iiii\", but the latter is a longer\n     * string - thus the calculation can go wrong (doing it properly and putting\n     * it into an DOM object and measuring that is horribly(!) slow). Thus as\n     * a \"work around\" we provide this option. It will append its value to the\n     * text that is found to be the longest string for the column - i.e. padding.\n     *  @type string\n     */\n    \"sContentPadding\": null,\n\n    /**\n     * Allows a default value to be given for a column's data, and will be used\n     * whenever a null data source is encountered (this can be because mData\n     * is set to null, or because the data source itself is null).\n     *  @type string\n     *  @default null\n     */\n    \"sDefaultContent\": null,\n\n    /**\n     * Name for the column, allowing reference to the column by name as well as\n     * by index (needs a lookup to work by name).\n     *  @type string\n     */\n    \"sName\": null,\n\n    /**\n     * Custom sorting data type - defines which of the available plug-ins in\n     * afnSortData the custom sorting will use - if any is defined.\n     *  @type string\n     *  @default std\n     */\n    \"sSortDataType\": 'std',\n\n    /**\n     * Class to be applied to the header element when sorting on this column\n     *  @type string\n     *  @default null\n     */\n    \"sSortingClass\": null,\n\n    /**\n     * Class to be applied to the header element when sorting on this column -\n     * when jQuery UI theming is used.\n     *  @type string\n     *  @default null\n     */\n    \"sSortingClassJUI\": null,\n\n    /**\n     * Title of the column - what is seen in the TH element (nTh).\n     *  @type string\n     */\n    \"sTitle\": null,\n\n    /**\n     * Column sorting and filtering type\n     *  @type string\n     *  @default null\n     */\n    \"sType\": null,\n\n    /**\n     * Width of the column\n     *  @type string\n     *  @default null\n     */\n    \"sWidth\": null,\n\n    /**\n     * Width of the column when it was first \"encountered\"\n     *  @type string\n     *  @default null\n     */\n    \"sWidthOrig\": null\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 at 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   */\n\n  DataTable.defaults = {\n    /**\n     * An array of data to use for the table, passed in at initialisation which\n     * will be used in preference to any data which is already in the DOM. This is\n     * particularly useful for constructing tables purely in Javascript, for\n     * example with a custom Ajax call.\n     *  @type array\n     *  @default null\n     *\n     *  @dtopt Option\n     *  @name DataTable.defaults.data\n     *\n     *  @example\n     *    // Using a 2D array data source\n     *    $(document).ready( function () {\n     *      $('#example').dataTable( {\n     *        \"data\": [\n     *          ['Trident', 'Internet Explorer 4.0', 'Win 95+', 4, 'X'],\n     *          ['Trident', 'Internet Explorer 5.0', 'Win 95+', 5, 'C'],\n     *        ],\n     *        \"columns\": [\n     *          { \"title\": \"Engine\" },\n     *          { \"title\": \"Browser\" },\n     *          { \"title\": \"Platform\" },\n     *          { \"title\": \"Version\" },\n     *          { \"title\": \"Grade\" }\n     *        ]\n     *      } );\n     *    } );\n     *\n     *  @example\n     *    // Using an array of objects as a data source (`data`)\n     *    $(document).ready( function () {\n     *      $('#example').dataTable( {\n     *        \"data\": [\n     *          {\n     *            \"engine\":   \"Trident\",\n     *            \"browser\":  \"Internet Explorer 4.0\",\n     *            \"platform\": \"Win 95+\",\n     *            \"version\":  4,\n     *            \"grade\":    \"X\"\n     *          },\n     *          {\n     *            \"engine\":   \"Trident\",\n     *            \"browser\":  \"Internet Explorer 5.0\",\n     *            \"platform\": \"Win 95+\",\n     *            \"version\":  5,\n     *            \"grade\":    \"C\"\n     *          }\n     *        ],\n     *        \"columns\": [\n     *          { \"title\": \"Engine\",   \"data\": \"engine\" },\n     *          { \"title\": \"Browser\",  \"data\": \"browser\" },\n     *          { \"title\": \"Platform\", \"data\": \"platform\" },\n     *          { \"title\": \"Version\",  \"data\": \"version\" },\n     *          { \"title\": \"Grade\",    \"data\": \"grade\" }\n     *        ]\n     *      } );\n     *    } );\n     */\n    \"aaData\": null,\n\n    /**\n     * If ordering is enabled, then DataTables will perform a first pass sort on\n     * initialisation. You can define which column(s) the sort is performed\n     * upon, and the sorting direction, with this variable. The `sorting` array\n     * should contain an array for each column to be sorted initially containing\n     * the column's index and a direction string ('asc' or 'desc').\n     *  @type array\n     *  @default [[0,'asc']]\n     *\n     *  @dtopt Option\n     *  @name DataTable.defaults.order\n     *\n     *  @example\n     *    // Sort by 3rd column first, and then 4th column\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"order\": [[2,'asc'], [3,'desc']]\n     *      } );\n     *    } );\n     *\n     *    // No initial sorting\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"order\": []\n     *      } );\n     *    } );\n     */\n    \"aaSorting\": [[0, 'asc']],\n\n    /**\n     * This parameter is basically identical to the `sorting` parameter, but\n     * cannot be overridden by user interaction with the table. What this means\n     * is that you could have a column (visible or hidden) which the sorting\n     * will always be forced on first - any sorting after that (from the user)\n     * will then be performed as required. This can be useful for grouping rows\n     * together.\n     *  @type array\n     *  @default null\n     *\n     *  @dtopt Option\n     *  @name DataTable.defaults.orderFixed\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"orderFixed\": [[0,'asc']]\n     *      } );\n     *    } )\n     */\n    \"aaSortingFixed\": [],\n\n    /**\n     * DataTables can be instructed to load data to display in the table from a\n     * Ajax source. This option defines how that Ajax call is made and where to.\n     *\n     * The `ajax` property has three different modes of operation, depending on\n     * how it is defined. These are:\n     *\n     * * `string` - Set the URL from where the data should be loaded from.\n     * * `object` - Define properties for `jQuery.ajax`.\n     * * `function` - Custom data get function\n     *\n     * `string`\n     * --------\n     *\n     * As a string, the `ajax` property simply defines the URL from which\n     * DataTables will load data.\n     *\n     * `object`\n     * --------\n     *\n     * As an object, the parameters in the object are passed to\n     * [jQuery.ajax](http://api.jquery.com/jQuery.ajax/) allowing fine control\n     * of the Ajax request. DataTables has a number of default parameters which\n     * you can override using this option. Please refer to the jQuery\n     * documentation for a full description of the options available, although\n     * the following parameters provide additional options in DataTables or\n     * require special consideration:\n     *\n     * * `data` - As with jQuery, `data` can be provided as an object, but it\n     *   can also be used as a function to manipulate the data DataTables sends\n     *   to the server. The function takes a single parameter, an object of\n     *   parameters with the values that DataTables has readied for sending. An\n     *   object may be returned which will be merged into the DataTables\n     *   defaults, or you can add the items to the object that was passed in and\n     *   not return anything from the function. This supersedes `fnServerParams`\n     *   from DataTables 1.9-.\n     *\n     * * `dataSrc` - By default DataTables will look for the property `data` (or\n     *   `aaData` for compatibility with DataTables 1.9-) when obtaining data\n     *   from an Ajax source or for server-side processing - this parameter\n     *   allows that property to be changed. You can use Javascript dotted\n     *   object notation to get a data source for multiple levels of nesting, or\n     *   it my be used as a function. As a function it takes a single parameter,\n     *   the JSON returned from the server, which can be manipulated as\n     *   required, with the returned value being that used by DataTables as the\n     *   data source for the table. This supersedes `sAjaxDataProp` from\n     *   DataTables 1.9-.\n     *\n     * * `success` - Should not be overridden it is used internally in\n     *   DataTables. To manipulate / transform the data returned by the server\n     *   use `ajax.dataSrc`, or use `ajax` as a function (see below).\n     *\n     * `function`\n     * ----------\n     *\n     * As a function, making the Ajax call is left up to yourself allowing\n     * complete control of the Ajax request. Indeed, if desired, a method other\n     * than Ajax could be used to obtain the required data, such as Web storage\n     * or an AIR database.\n     *\n     * The function is given four parameters and no return is required. The\n     * parameters are:\n     *\n     * 1. _object_ - Data to send to the server\n     * 2. _function_ - Callback function that must be executed when the required\n     *    data has been obtained. That data should be passed into the callback\n     *    as the only parameter\n     * 3. _object_ - DataTables settings object for the table\n     *\n     * Note that this supersedes `fnServerData` from DataTables 1.9-.\n     *\n     *  @type string|object|function\n     *  @default null\n     *\n     *  @dtopt Option\n     *  @name DataTable.defaults.ajax\n     *  @since 1.10.0\n     *\n     * @example\n     *   // Get JSON data from a file via Ajax.\n     *   // Note DataTables expects data in the form `{ data: [ ...data... ] }` by default).\n     *   $('#example').dataTable( {\n     *     \"ajax\": \"data.json\"\n     *   } );\n     *\n     * @example\n     *   // Get JSON data from a file via Ajax, using `dataSrc` to change\n     *   // `data` to `tableData` (i.e. `{ tableData: [ ...data... ] }`)\n     *   $('#example').dataTable( {\n     *     \"ajax\": {\n     *       \"url\": \"data.json\",\n     *       \"dataSrc\": \"tableData\"\n     *     }\n     *   } );\n     *\n     * @example\n     *   // Get JSON data from a file via Ajax, using `dataSrc` to read data\n     *   // from a plain array rather than an array in an object\n     *   $('#example').dataTable( {\n     *     \"ajax\": {\n     *       \"url\": \"data.json\",\n     *       \"dataSrc\": \"\"\n     *     }\n     *   } );\n     *\n     * @example\n     *   // Manipulate the data returned from the server - add a link to data\n     *   // (note this can, should, be done using `render` for the column - this\n     *   // is just a simple example of how the data can be manipulated).\n     *   $('#example').dataTable( {\n     *     \"ajax\": {\n     *       \"url\": \"data.json\",\n     *       \"dataSrc\": function ( json ) {\n     *         for ( var i=0, ien=json.length ; i<ien ; i++ ) {\n     *           json[i][0] = '<a href=\"/message/'+json[i][0]+'>View message</a>';\n     *         }\n     *         return json;\n     *       }\n     *     }\n     *   } );\n     *\n     * @example\n     *   // Add data to the request\n     *   $('#example').dataTable( {\n     *     \"ajax\": {\n     *       \"url\": \"data.json\",\n     *       \"data\": function ( d ) {\n     *         return {\n     *           \"extra_search\": $('#extra').val()\n     *         };\n     *       }\n     *     }\n     *   } );\n     *\n     * @example\n     *   // Send request as POST\n     *   $('#example').dataTable( {\n     *     \"ajax\": {\n     *       \"url\": \"data.json\",\n     *       \"type\": \"POST\"\n     *     }\n     *   } );\n     *\n     * @example\n     *   // Get the data from localStorage (could interface with a form for\n     *   // adding, editing and removing rows).\n     *   $('#example').dataTable( {\n     *     \"ajax\": function (data, callback, settings) {\n     *       callback(\n     *         JSON.parse( localStorage.getItem('dataTablesData') )\n     *       );\n     *     }\n     *   } );\n     */\n    \"ajax\": null,\n\n    /**\n     * This parameter allows you to readily specify the entries in the length drop\n     * down menu that DataTables shows when pagination is enabled. It can be\n     * either a 1D array of options which will be used for both the displayed\n     * option and the value, or a 2D array which will use the array in the first\n     * position as the value, and the array in the second position as the\n     * displayed options (useful for language strings such as 'All').\n     *\n     * Note that the `pageLength` property will be automatically set to the\n     * first value given in this array, unless `pageLength` is also provided.\n     *  @type array\n     *  @default [ 10, 25, 50, 100 ]\n     *\n     *  @dtopt Option\n     *  @name DataTable.defaults.lengthMenu\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"lengthMenu\": [[10, 25, 50, -1], [10, 25, 50, \"All\"]]\n     *      } );\n     *    } );\n     */\n    \"aLengthMenu\": [10, 25, 50, 100],\n\n    /**\n     * The `columns` option in the initialisation parameter allows you to define\n     * details about the way individual columns behave. For a full list of\n     * column options that can be set, please see\n     * {@link DataTable.defaults.column}. Note that if you use `columns` to\n     * define your columns, you must have an entry in the array for every single\n     * column that you have in your table (these can be null if you don't which\n     * to specify any options).\n     *  @member\n     *\n     *  @name DataTable.defaults.column\n     */\n    \"aoColumns\": null,\n\n    /**\n     * Very similar to `columns`, `columnDefs` allows you to target a specific\n     * column, multiple columns, or all columns, using the `targets` property of\n     * each object in the array. This allows great flexibility when creating\n     * tables, as the `columnDefs` arrays can be of any length, targeting the\n     * columns you specifically want. `columnDefs` may use any of the column\n     * options available: {@link DataTable.defaults.column}, but it _must_\n     * have `targets` defined in each object in the array. Values in the `targets`\n     * array may be:\n     *   <ul>\n     *     <li>a string - class name will be matched on the TH for the column</li>\n     *     <li>0 or a positive integer - column index counting from the left</li>\n     *     <li>a negative integer - column index counting from the right</li>\n     *     <li>the string \"_all\" - all columns (i.e. assign a default)</li>\n     *   </ul>\n     *  @member\n     *\n     *  @name DataTable.defaults.columnDefs\n     */\n    \"aoColumnDefs\": null,\n\n    /**\n     * Basically the same as `search`, this parameter defines the individual column\n     * filtering state at initialisation time. The array must be of the same size\n     * as the number of columns, and each element be an object with the parameters\n     * `search` and `escapeRegex` (the latter is optional). 'null' is also\n     * accepted and the default will be used.\n     *  @type array\n     *  @default []\n     *\n     *  @dtopt Option\n     *  @name DataTable.defaults.searchCols\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"searchCols\": [\n     *          null,\n     *          { \"search\": \"My filter\" },\n     *          null,\n     *          { \"search\": \"^[0-9]\", \"escapeRegex\": false }\n     *        ]\n     *      } );\n     *    } )\n     */\n    \"aoSearchCols\": [],\n\n    /**\n     * An array of CSS classes that should be applied to displayed rows. This\n     * array may be of any length, and DataTables will apply each class\n     * sequentially, looping when required.\n     *  @type array\n     *  @default null <i>Will take the values determined by the `oClasses.stripe*`\n     *    options</i>\n     *\n     *  @dtopt Option\n     *  @name DataTable.defaults.stripeClasses\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"stripeClasses\": [ 'strip1', 'strip2', 'strip3' ]\n     *      } );\n     *    } )\n     */\n    \"asStripeClasses\": null,\n\n    /**\n     * Enable or disable automatic column width calculation. This can be disabled\n     * as an optimisation (it takes some time to calculate the widths) if the\n     * tables widths are passed in using `columns`.\n     *  @type boolean\n     *  @default true\n     *\n     *  @dtopt Features\n     *  @name DataTable.defaults.autoWidth\n     *\n     *  @example\n     *    $(document).ready( function () {\n     *      $('#example').dataTable( {\n     *        \"autoWidth\": false\n     *      } );\n     *    } );\n     */\n    \"bAutoWidth\": true,\n\n    /**\n     * Deferred rendering can provide DataTables with a huge speed boost when you\n     * are using an Ajax or JS data source for the table. This option, when set to\n     * true, will cause DataTables to defer the creation of the table elements for\n     * each row until they are needed for a draw - saving a significant amount of\n     * time.\n     *  @type boolean\n     *  @default false\n     *\n     *  @dtopt Features\n     *  @name DataTable.defaults.deferRender\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"ajax\": \"sources/arrays.txt\",\n     *        \"deferRender\": true\n     *      } );\n     *    } );\n     */\n    \"bDeferRender\": false,\n\n    /**\n     * Replace a DataTable which matches the given selector and replace it with\n     * one which has the properties of the new initialisation object passed. If no\n     * table matches the selector, then the new DataTable will be constructed as\n     * per normal.\n     *  @type boolean\n     *  @default false\n     *\n     *  @dtopt Options\n     *  @name DataTable.defaults.destroy\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"srollY\": \"200px\",\n     *        \"paginate\": false\n     *      } );\n     *\n     *      // Some time later....\n     *      $('#example').dataTable( {\n     *        \"filter\": false,\n     *        \"destroy\": true\n     *      } );\n     *    } );\n     */\n    \"bDestroy\": false,\n\n    /**\n     * Enable or disable filtering of data. Filtering in DataTables is \"smart\" in\n     * that it allows the end user to input multiple words (space separated) and\n     * will match a row containing those words, even if not in the order that was\n     * specified (this allow matching across multiple columns). Note that if you\n     * wish to use filtering in DataTables this must remain 'true' - to remove the\n     * default filtering input box and retain filtering abilities, please use\n     * {@link DataTable.defaults.dom}.\n     *  @type boolean\n     *  @default true\n     *\n     *  @dtopt Features\n     *  @name DataTable.defaults.searching\n     *\n     *  @example\n     *    $(document).ready( function () {\n     *      $('#example').dataTable( {\n     *        \"searching\": false\n     *      } );\n     *    } );\n     */\n    \"bFilter\": true,\n\n    /**\n     * Enable or disable the table information display. This shows information\n     * about the data that is currently visible on the page, including information\n     * about filtered data if that action is being performed.\n     *  @type boolean\n     *  @default true\n     *\n     *  @dtopt Features\n     *  @name DataTable.defaults.info\n     *\n     *  @example\n     *    $(document).ready( function () {\n     *      $('#example').dataTable( {\n     *        \"info\": false\n     *      } );\n     *    } );\n     */\n    \"bInfo\": true,\n\n    /**\n     * Allows the end user to select the size of a formatted page from a select\n     * menu (sizes are 10, 25, 50 and 100). Requires pagination (`paginate`).\n     *  @type boolean\n     *  @default true\n     *\n     *  @dtopt Features\n     *  @name DataTable.defaults.lengthChange\n     *\n     *  @example\n     *    $(document).ready( function () {\n     *      $('#example').dataTable( {\n     *        \"lengthChange\": false\n     *      } );\n     *    } );\n     */\n    \"bLengthChange\": true,\n\n    /**\n     * Enable or disable pagination.\n     *  @type boolean\n     *  @default true\n     *\n     *  @dtopt Features\n     *  @name DataTable.defaults.paging\n     *\n     *  @example\n     *    $(document).ready( function () {\n     *      $('#example').dataTable( {\n     *        \"paging\": false\n     *      } );\n     *    } );\n     */\n    \"bPaginate\": true,\n\n    /**\n     * Enable or disable the display of a 'processing' indicator when the table is\n     * being processed (e.g. a sort). This is particularly useful for tables with\n     * large amounts of data where it can take a noticeable amount of time to sort\n     * the entries.\n     *  @type boolean\n     *  @default false\n     *\n     *  @dtopt Features\n     *  @name DataTable.defaults.processing\n     *\n     *  @example\n     *    $(document).ready( function () {\n     *      $('#example').dataTable( {\n     *        \"processing\": true\n     *      } );\n     *    } );\n     */\n    \"bProcessing\": false,\n\n    /**\n     * Retrieve the DataTables object for the given selector. Note that if the\n     * table has already been initialised, this parameter will cause DataTables\n     * to simply return the object that has already been set up - it will not take\n     * account of any changes you might have made to the initialisation object\n     * passed to DataTables (setting this parameter to true is an acknowledgement\n     * that you understand this). `destroy` can be used to reinitialise a table if\n     * you need.\n     *  @type boolean\n     *  @default false\n     *\n     *  @dtopt Options\n     *  @name DataTable.defaults.retrieve\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      initTable();\n     *      tableActions();\n     *    } );\n     *\n     *    function initTable ()\n     *    {\n     *      return $('#example').dataTable( {\n     *        \"scrollY\": \"200px\",\n     *        \"paginate\": false,\n     *        \"retrieve\": true\n     *      } );\n     *    }\n     *\n     *    function tableActions ()\n     *    {\n     *      var table = initTable();\n     *      // perform API operations with oTable\n     *    }\n     */\n    \"bRetrieve\": false,\n\n    /**\n     * When vertical (y) scrolling is enabled, DataTables will force the height of\n     * the table's viewport to the given height at all times (useful for layout).\n     * However, this can look odd when filtering data down to a small data set,\n     * and the footer is left \"floating\" further down. This parameter (when\n     * enabled) will cause DataTables to collapse the table's viewport down when\n     * the result set will fit within the given Y height.\n     *  @type boolean\n     *  @default false\n     *\n     *  @dtopt Options\n     *  @name DataTable.defaults.scrollCollapse\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"scrollY\": \"200\",\n     *        \"scrollCollapse\": true\n     *      } );\n     *    } );\n     */\n    \"bScrollCollapse\": false,\n\n    /**\n     * Configure DataTables to use server-side processing. Note that the\n     * `ajax` parameter must also be given in order to give DataTables a\n     * source to obtain the required data for each draw.\n     *  @type boolean\n     *  @default false\n     *\n     *  @dtopt Features\n     *  @dtopt Server-side\n     *  @name DataTable.defaults.serverSide\n     *\n     *  @example\n     *    $(document).ready( function () {\n     *      $('#example').dataTable( {\n     *        \"serverSide\": true,\n     *        \"ajax\": \"xhr.php\"\n     *      } );\n     *    } );\n     */\n    \"bServerSide\": false,\n\n    /**\n     * Enable or disable sorting of columns. Sorting of individual columns can be\n     * disabled by the `sortable` option for each column.\n     *  @type boolean\n     *  @default true\n     *\n     *  @dtopt Features\n     *  @name DataTable.defaults.ordering\n     *\n     *  @example\n     *    $(document).ready( function () {\n     *      $('#example').dataTable( {\n     *        \"ordering\": false\n     *      } );\n     *    } );\n     */\n    \"bSort\": true,\n\n    /**\n     * Enable or display DataTables' ability to sort multiple columns at the\n     * same time (activated by shift-click by the user).\n     *  @type boolean\n     *  @default true\n     *\n     *  @dtopt Options\n     *  @name DataTable.defaults.orderMulti\n     *\n     *  @example\n     *    // Disable multiple column sorting ability\n     *    $(document).ready( function () {\n     *      $('#example').dataTable( {\n     *        \"orderMulti\": false\n     *      } );\n     *    } );\n     */\n    \"bSortMulti\": true,\n\n    /**\n     * Allows control over whether DataTables should use the top (true) unique\n     * cell that is found for a single column, or the bottom (false - default).\n     * This is useful when using complex headers.\n     *  @type boolean\n     *  @default false\n     *\n     *  @dtopt Options\n     *  @name DataTable.defaults.orderCellsTop\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"orderCellsTop\": true\n     *      } );\n     *    } );\n     */\n    \"bSortCellsTop\": false,\n\n    /**\n     * Enable or disable the addition of the classes `sorting\\_1`, `sorting\\_2` and\n     * `sorting\\_3` to the columns which are currently being sorted on. This is\n     * presented as a feature switch as it can increase processing time (while\n     * classes are removed and added) so for large data sets you might want to\n     * turn this off.\n     *  @type boolean\n     *  @default true\n     *\n     *  @dtopt Features\n     *  @name DataTable.defaults.orderClasses\n     *\n     *  @example\n     *    $(document).ready( function () {\n     *      $('#example').dataTable( {\n     *        \"orderClasses\": false\n     *      } );\n     *    } );\n     */\n    \"bSortClasses\": true,\n\n    /**\n     * Enable or disable state saving. When enabled HTML5 `localStorage` will be\n     * used to save table display information such as pagination information,\n     * display length, filtering and sorting. As such when the end user reloads\n     * the page the display display will match what thy had previously set up.\n     *\n     * Due to the use of `localStorage` the default state saving is not supported\n     * in IE6 or 7. If state saving is required in those browsers, use\n     * `stateSaveCallback` to provide a storage solution such as cookies.\n     *  @type boolean\n     *  @default false\n     *\n     *  @dtopt Features\n     *  @name DataTable.defaults.stateSave\n     *\n     *  @example\n     *    $(document).ready( function () {\n     *      $('#example').dataTable( {\n     *        \"stateSave\": true\n     *      } );\n     *    } );\n     */\n    \"bStateSave\": false,\n\n    /**\n     * This function is called when a TR element is created (and all TD child\n     * elements have been inserted), or registered if using a DOM source, allowing\n     * manipulation of the TR element (adding classes etc).\n     *  @type function\n     *  @param {node} row \"TR\" element for the current row\n     *  @param {array} data Raw data array for this row\n     *  @param {int} dataIndex The index of this row in the internal aoData array\n     *\n     *  @dtopt Callbacks\n     *  @name DataTable.defaults.createdRow\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"createdRow\": function( row, data, dataIndex ) {\n     *          // Bold the grade for all 'A' grade browsers\n     *          if ( data[4] == \"A\" )\n     *          {\n     *            $('td:eq(4)', row).html( '<b>A</b>' );\n     *          }\n     *        }\n     *      } );\n     *    } );\n     */\n    \"fnCreatedRow\": null,\n\n    /**\n     * This function is called on every 'draw' event, and allows you to\n     * dynamically modify any aspect you want about the created DOM.\n     *  @type function\n     *  @param {object} settings DataTables settings object\n     *\n     *  @dtopt Callbacks\n     *  @name DataTable.defaults.drawCallback\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"drawCallback\": function( settings ) {\n     *          alert( 'DataTables has redrawn the table' );\n     *        }\n     *      } );\n     *    } );\n     */\n    \"fnDrawCallback\": null,\n\n    /**\n     * Identical to fnHeaderCallback() but for the table footer this function\n     * allows you to modify the table footer on every 'draw' event.\n     *  @type function\n     *  @param {node} foot \"TR\" element for the footer\n     *  @param {array} data Full table data (as derived from the original HTML)\n     *  @param {int} start Index for the current display starting point in the\n     *    display array\n     *  @param {int} end Index for the current display ending point in the\n     *    display array\n     *  @param {array int} display Index array to translate the visual position\n     *    to the full data array\n     *\n     *  @dtopt Callbacks\n     *  @name DataTable.defaults.footerCallback\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"footerCallback\": function( tfoot, data, start, end, display ) {\n     *          tfoot.getElementsByTagName('th')[0].innerHTML = \"Starting index is \"+start;\n     *        }\n     *      } );\n     *    } )\n     */\n    \"fnFooterCallback\": null,\n\n    /**\n     * When rendering large numbers in the information element for the table\n     * (i.e. \"Showing 1 to 10 of 57 entries\") DataTables will render large numbers\n     * to have a comma separator for the 'thousands' units (e.g. 1 million is\n     * rendered as \"1,000,000\") to help readability for the end user. This\n     * function will override the default method DataTables uses.\n     *  @type function\n     *  @member\n     *  @param {int} toFormat number to be formatted\n     *  @returns {string} formatted string for DataTables to show the number\n     *\n     *  @dtopt Callbacks\n     *  @name DataTable.defaults.formatNumber\n     *\n     *  @example\n     *    // Format a number using a single quote for the separator (note that\n     *    // this can also be done with the language.thousands option)\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"formatNumber\": function ( toFormat ) {\n     *          return toFormat.toString().replace(\n     *            /\\B(?=(\\d{3})+(?!\\d))/g, \"'\"\n     *          );\n     *        };\n     *      } );\n     *    } );\n     */\n    \"fnFormatNumber\": function fnFormatNumber(toFormat) {\n      return toFormat.toString().replace(/\\B(?=(\\d{3})+(?!\\d))/g, this.oLanguage.sThousands);\n    },\n\n    /**\n     * This function is called on every 'draw' event, and allows you to\n     * dynamically modify the header row. This can be used to calculate and\n     * display useful information about the table.\n     *  @type function\n     *  @param {node} head \"TR\" element for the header\n     *  @param {array} data Full table data (as derived from the original HTML)\n     *  @param {int} start Index for the current display starting point in the\n     *    display array\n     *  @param {int} end Index for the current display ending point in the\n     *    display array\n     *  @param {array int} display Index array to translate the visual position\n     *    to the full data array\n     *\n     *  @dtopt Callbacks\n     *  @name DataTable.defaults.headerCallback\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"fheaderCallback\": function( head, data, start, end, display ) {\n     *          head.getElementsByTagName('th')[0].innerHTML = \"Displaying \"+(end-start)+\" records\";\n     *        }\n     *      } );\n     *    } )\n     */\n    \"fnHeaderCallback\": null,\n\n    /**\n     * The information element can be used to convey information about the current\n     * state of the table. Although the internationalisation options presented by\n     * DataTables are quite capable of dealing with most customisations, there may\n     * be times where you wish to customise the string further. This callback\n     * allows you to do exactly that.\n     *  @type function\n     *  @param {object} oSettings DataTables settings object\n     *  @param {int} start Starting position in data for the draw\n     *  @param {int} end End position in data for the draw\n     *  @param {int} max Total number of rows in the table (regardless of\n     *    filtering)\n     *  @param {int} total Total number of rows in the data set, after filtering\n     *  @param {string} pre The string that DataTables has formatted using it's\n     *    own rules\n     *  @returns {string} The string to be displayed in the information element.\n     *\n     *  @dtopt Callbacks\n     *  @name DataTable.defaults.infoCallback\n     *\n     *  @example\n     *    $('#example').dataTable( {\n     *      \"infoCallback\": function( settings, start, end, max, total, pre ) {\n     *        return start +\" to \"+ end;\n     *      }\n     *    } );\n     */\n    \"fnInfoCallback\": null,\n\n    /**\n     * Called when the table has been initialised. Normally DataTables will\n     * initialise sequentially and there will be no need for this function,\n     * however, this does not hold true when using external language information\n     * since that is obtained using an async XHR call.\n     *  @type function\n     *  @param {object} settings DataTables settings object\n     *  @param {object} json The JSON object request from the server - only\n     *    present if client-side Ajax sourced data is used\n     *\n     *  @dtopt Callbacks\n     *  @name DataTable.defaults.initComplete\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"initComplete\": function(settings, json) {\n     *          alert( 'DataTables has finished its initialisation.' );\n     *        }\n     *      } );\n     *    } )\n     */\n    \"fnInitComplete\": null,\n\n    /**\n     * Called at the very start of each table draw and can be used to cancel the\n     * draw by returning false, any other return (including undefined) results in\n     * the full draw occurring).\n     *  @type function\n     *  @param {object} settings DataTables settings object\n     *  @returns {boolean} False will cancel the draw, anything else (including no\n     *    return) will allow it to complete.\n     *\n     *  @dtopt Callbacks\n     *  @name DataTable.defaults.preDrawCallback\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"preDrawCallback\": function( settings ) {\n     *          if ( $('#test').val() == 1 ) {\n     *            return false;\n     *          }\n     *        }\n     *      } );\n     *    } );\n     */\n    \"fnPreDrawCallback\": null,\n\n    /**\n     * This function allows you to 'post process' each row after it have been\n     * generated for each table draw, but before it is rendered on screen. This\n     * function might be used for setting the row class name etc.\n     *  @type function\n     *  @param {node} row \"TR\" element for the current row\n     *  @param {array} data Raw data array for this row\n     *  @param {int} displayIndex The display index for the current table draw\n     *  @param {int} displayIndexFull The index of the data in the full list of\n     *    rows (after filtering)\n     *\n     *  @dtopt Callbacks\n     *  @name DataTable.defaults.rowCallback\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"rowCallback\": function( row, data, displayIndex, displayIndexFull ) {\n     *          // Bold the grade for all 'A' grade browsers\n     *          if ( data[4] == \"A\" ) {\n     *            $('td:eq(4)', row).html( '<b>A</b>' );\n     *          }\n     *        }\n     *      } );\n     *    } );\n     */\n    \"fnRowCallback\": null,\n\n    /**\n     * __Deprecated__ The functionality provided by this parameter has now been\n     * superseded by that provided through `ajax`, which should be used instead.\n     *\n     * This parameter allows you to override the default function which obtains\n     * the data from the server so something more suitable for your application.\n     * For example you could use POST data, or pull information from a Gears or\n     * AIR database.\n     *  @type function\n     *  @member\n     *  @param {string} source HTTP source to obtain the data from (`ajax`)\n     *  @param {array} data A key/value pair object containing the data to send\n     *    to the server\n     *  @param {function} callback to be called on completion of the data get\n     *    process that will draw the data on the page.\n     *  @param {object} settings DataTables settings object\n     *\n     *  @dtopt Callbacks\n     *  @dtopt Server-side\n     *  @name DataTable.defaults.serverData\n     *\n     *  @deprecated 1.10. Please use `ajax` for this functionality now.\n     */\n    \"fnServerData\": null,\n\n    /**\n     * __Deprecated__ The functionality provided by this parameter has now been\n     * superseded by that provided through `ajax`, which should be used instead.\n     *\n     *  It is often useful to send extra data to the server when making an Ajax\n     * request - for example custom filtering information, and this callback\n     * function makes it trivial to send extra information to the server. The\n     * passed in parameter is the data set that has been constructed by\n     * DataTables, and you can add to this or modify it as you require.\n     *  @type function\n     *  @param {array} data Data array (array of objects which are name/value\n     *    pairs) that has been constructed by DataTables and will be sent to the\n     *    server. In the case of Ajax sourced data with server-side processing\n     *    this will be an empty array, for server-side processing there will be a\n     *    significant number of parameters!\n     *  @returns {undefined} Ensure that you modify the data array passed in,\n     *    as this is passed by reference.\n     *\n     *  @dtopt Callbacks\n     *  @dtopt Server-side\n     *  @name DataTable.defaults.serverParams\n     *\n     *  @deprecated 1.10. Please use `ajax` for this functionality now.\n     */\n    \"fnServerParams\": null,\n\n    /**\n     * Load the table state. With this function you can define from where, and how, the\n     * state of a table is loaded. By default DataTables will load from `localStorage`\n     * but you might wish to use a server-side database or cookies.\n     *  @type function\n     *  @member\n     *  @param {object} settings DataTables settings object\n     *  @param {object} callback Callback that can be executed when done. It\n     *    should be passed the loaded state object.\n     *  @return {object} The DataTables state object to be loaded\n     *\n     *  @dtopt Callbacks\n     *  @name DataTable.defaults.stateLoadCallback\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"stateSave\": true,\n     *        \"stateLoadCallback\": function (settings, callback) {\n     *          $.ajax( {\n     *            \"url\": \"/state_load\",\n     *            \"dataType\": \"json\",\n     *            \"success\": function (json) {\n     *              callback( json );\n     *            }\n     *          } );\n     *        }\n     *      } );\n     *    } );\n     */\n    \"fnStateLoadCallback\": function fnStateLoadCallback(settings) {\n      try {\n        return JSON.parse((settings.iStateDuration === -1 ? sessionStorage : localStorage).getItem('DataTables_' + settings.sInstance + '_' + location.pathname));\n      } catch (e) {}\n    },\n\n    /**\n     * Callback which allows modification of the saved state prior to loading that state.\n     * This callback is called when the table is loading state from the stored data, but\n     * prior to the settings object being modified by the saved state. Note that for\n     * plug-in authors, you should use the `stateLoadParams` event to load parameters for\n     * a plug-in.\n     *  @type function\n     *  @param {object} settings DataTables settings object\n     *  @param {object} data The state object that is to be loaded\n     *\n     *  @dtopt Callbacks\n     *  @name DataTable.defaults.stateLoadParams\n     *\n     *  @example\n     *    // Remove a saved filter, so filtering is never loaded\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"stateSave\": true,\n     *        \"stateLoadParams\": function (settings, data) {\n     *          data.oSearch.sSearch = \"\";\n     *        }\n     *      } );\n     *    } );\n     *\n     *  @example\n     *    // Disallow state loading by returning false\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"stateSave\": true,\n     *        \"stateLoadParams\": function (settings, data) {\n     *          return false;\n     *        }\n     *      } );\n     *    } );\n     */\n    \"fnStateLoadParams\": null,\n\n    /**\n     * Callback that is called when the state has been loaded from the state saving method\n     * and the DataTables settings object has been modified as a result of the loaded state.\n     *  @type function\n     *  @param {object} settings DataTables settings object\n     *  @param {object} data The state object that was loaded\n     *\n     *  @dtopt Callbacks\n     *  @name DataTable.defaults.stateLoaded\n     *\n     *  @example\n     *    // Show an alert with the filtering value that was saved\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"stateSave\": true,\n     *        \"stateLoaded\": function (settings, data) {\n     *          alert( 'Saved filter was: '+data.oSearch.sSearch );\n     *        }\n     *      } );\n     *    } );\n     */\n    \"fnStateLoaded\": null,\n\n    /**\n     * Save the table state. This function allows you to define where and how the state\n     * information for the table is stored By default DataTables will use `localStorage`\n     * but you might wish to use a server-side database or cookies.\n     *  @type function\n     *  @member\n     *  @param {object} settings DataTables settings object\n     *  @param {object} data The state object to be saved\n     *\n     *  @dtopt Callbacks\n     *  @name DataTable.defaults.stateSaveCallback\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"stateSave\": true,\n     *        \"stateSaveCallback\": function (settings, data) {\n     *          // Send an Ajax request to the server with the state object\n     *          $.ajax( {\n     *            \"url\": \"/state_save\",\n     *            \"data\": data,\n     *            \"dataType\": \"json\",\n     *            \"method\": \"POST\"\n     *            \"success\": function () {}\n     *          } );\n     *        }\n     *      } );\n     *    } );\n     */\n    \"fnStateSaveCallback\": function fnStateSaveCallback(settings, data) {\n      try {\n        (settings.iStateDuration === -1 ? sessionStorage : localStorage).setItem('DataTables_' + settings.sInstance + '_' + location.pathname, JSON.stringify(data));\n      } catch (e) {}\n    },\n\n    /**\n     * Callback which allows modification of the state to be saved. Called when the table\n     * has changed state a new state save is required. This method allows modification of\n     * the state saving object prior to actually doing the save, including addition or\n     * other state properties or modification. Note that for plug-in authors, you should\n     * use the `stateSaveParams` event to save parameters for a plug-in.\n     *  @type function\n     *  @param {object} settings DataTables settings object\n     *  @param {object} data The state object to be saved\n     *\n     *  @dtopt Callbacks\n     *  @name DataTable.defaults.stateSaveParams\n     *\n     *  @example\n     *    // Remove a saved filter, so filtering is never saved\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"stateSave\": true,\n     *        \"stateSaveParams\": function (settings, data) {\n     *          data.oSearch.sSearch = \"\";\n     *        }\n     *      } );\n     *    } );\n     */\n    \"fnStateSaveParams\": null,\n\n    /**\n     * Duration for which the saved state information is considered valid. After this period\n     * has elapsed the state will be returned to the default.\n     * Value is given in seconds.\n     *  @type int\n     *  @default 7200 <i>(2 hours)</i>\n     *\n     *  @dtopt Options\n     *  @name DataTable.defaults.stateDuration\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"stateDuration\": 60*60*24; // 1 day\n     *      } );\n     *    } )\n     */\n    \"iStateDuration\": 7200,\n\n    /**\n     * When enabled DataTables will not make a request to the server for the first\n     * page draw - rather it will use the data already on the page (no sorting etc\n     * will be applied to it), thus saving on an XHR at load time. `deferLoading`\n     * is used to indicate that deferred loading is required, but it is also used\n     * to tell DataTables how many records there are in the full table (allowing\n     * the information element and pagination to be displayed correctly). In the case\n     * where a filtering is applied to the table on initial load, this can be\n     * indicated by giving the parameter as an array, where the first element is\n     * the number of records available after filtering and the second element is the\n     * number of records without filtering (allowing the table information element\n     * to be shown correctly).\n     *  @type int | array\n     *  @default null\n     *\n     *  @dtopt Options\n     *  @name DataTable.defaults.deferLoading\n     *\n     *  @example\n     *    // 57 records available in the table, no filtering applied\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"serverSide\": true,\n     *        \"ajax\": \"scripts/server_processing.php\",\n     *        \"deferLoading\": 57\n     *      } );\n     *    } );\n     *\n     *  @example\n     *    // 57 records after filtering, 100 without filtering (an initial filter applied)\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"serverSide\": true,\n     *        \"ajax\": \"scripts/server_processing.php\",\n     *        \"deferLoading\": [ 57, 100 ],\n     *        \"search\": {\n     *          \"search\": \"my_filter\"\n     *        }\n     *      } );\n     *    } );\n     */\n    \"iDeferLoading\": null,\n\n    /**\n     * Number of rows to display on a single page when using pagination. If\n     * feature enabled (`lengthChange`) then the end user will be able to override\n     * this to a custom setting using a pop-up menu.\n     *  @type int\n     *  @default 10\n     *\n     *  @dtopt Options\n     *  @name DataTable.defaults.pageLength\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"pageLength\": 50\n     *      } );\n     *    } )\n     */\n    \"iDisplayLength\": 10,\n\n    /**\n     * Define the starting point for data display when using DataTables with\n     * pagination. Note that this parameter is the number of records, rather than\n     * the page number, so if you have 10 records per page and want to start on\n     * the third page, it should be \"20\".\n     *  @type int\n     *  @default 0\n     *\n     *  @dtopt Options\n     *  @name DataTable.defaults.displayStart\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"displayStart\": 20\n     *      } );\n     *    } )\n     */\n    \"iDisplayStart\": 0,\n\n    /**\n     * By default DataTables allows keyboard navigation of the table (sorting, paging,\n     * and filtering) by adding a `tabindex` attribute to the required elements. This\n     * allows you to tab through the controls and press the enter key to activate them.\n     * The tabindex is default 0, meaning that the tab follows the flow of the document.\n     * You can overrule this using this parameter if you wish. Use a value of -1 to\n     * disable built-in keyboard navigation.\n     *  @type int\n     *  @default 0\n     *\n     *  @dtopt Options\n     *  @name DataTable.defaults.tabIndex\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"tabIndex\": 1\n     *      } );\n     *    } );\n     */\n    \"iTabIndex\": 0,\n\n    /**\n     * Classes that DataTables assigns to the various components and features\n     * that it adds to the HTML table. This allows classes to be configured\n     * during initialisation in addition to through the static\n     * {@link DataTable.ext.oStdClasses} object).\n     *  @namespace\n     *  @name DataTable.defaults.classes\n     */\n    \"oClasses\": {},\n\n    /**\n     * All strings that DataTables uses in the user interface that it creates\n     * are defined in this object, allowing you to modified them individually or\n     * completely replace them all as required.\n     *  @namespace\n     *  @name DataTable.defaults.language\n     */\n    \"oLanguage\": {\n      /**\n       * Strings that are used for WAI-ARIA labels and controls only (these are not\n       * actually visible on the page, but will be read by screenreaders, and thus\n       * must be internationalised as well).\n       *  @namespace\n       *  @name DataTable.defaults.language.aria\n       */\n      \"oAria\": {\n        /**\n         * ARIA label that is added to the table headers when the column may be\n         * sorted ascending by activing the column (click or return when focused).\n         * Note that the column header is prefixed to this string.\n         *  @type string\n         *  @default : activate to sort column ascending\n         *\n         *  @dtopt Language\n         *  @name DataTable.defaults.language.aria.sortAscending\n         *\n         *  @example\n         *    $(document).ready( function() {\n         *      $('#example').dataTable( {\n         *        \"language\": {\n         *          \"aria\": {\n         *            \"sortAscending\": \" - click/return to sort ascending\"\n         *          }\n         *        }\n         *      } );\n         *    } );\n         */\n        \"sSortAscending\": \": activate to sort column ascending\",\n\n        /**\n         * ARIA label that is added to the table headers when the column may be\n         * sorted descending by activing the column (click or return when focused).\n         * Note that the column header is prefixed to this string.\n         *  @type string\n         *  @default : activate to sort column ascending\n         *\n         *  @dtopt Language\n         *  @name DataTable.defaults.language.aria.sortDescending\n         *\n         *  @example\n         *    $(document).ready( function() {\n         *      $('#example').dataTable( {\n         *        \"language\": {\n         *          \"aria\": {\n         *            \"sortDescending\": \" - click/return to sort descending\"\n         *          }\n         *        }\n         *      } );\n         *    } );\n         */\n        \"sSortDescending\": \": activate to sort column descending\"\n      },\n\n      /**\n       * Pagination string used by DataTables for the built-in pagination\n       * control types.\n       *  @namespace\n       *  @name DataTable.defaults.language.paginate\n       */\n      \"oPaginate\": {\n        /**\n         * Text to use when using the 'full_numbers' type of pagination for the\n         * button to take the user to the first page.\n         *  @type string\n         *  @default First\n         *\n         *  @dtopt Language\n         *  @name DataTable.defaults.language.paginate.first\n         *\n         *  @example\n         *    $(document).ready( function() {\n         *      $('#example').dataTable( {\n         *        \"language\": {\n         *          \"paginate\": {\n         *            \"first\": \"First page\"\n         *          }\n         *        }\n         *      } );\n         *    } );\n         */\n        \"sFirst\": \"First\",\n\n        /**\n         * Text to use when using the 'full_numbers' type of pagination for the\n         * button to take the user to the last page.\n         *  @type string\n         *  @default Last\n         *\n         *  @dtopt Language\n         *  @name DataTable.defaults.language.paginate.last\n         *\n         *  @example\n         *    $(document).ready( function() {\n         *      $('#example').dataTable( {\n         *        \"language\": {\n         *          \"paginate\": {\n         *            \"last\": \"Last page\"\n         *          }\n         *        }\n         *      } );\n         *    } );\n         */\n        \"sLast\": \"Last\",\n\n        /**\n         * Text to use for the 'next' pagination button (to take the user to the\n         * next page).\n         *  @type string\n         *  @default Next\n         *\n         *  @dtopt Language\n         *  @name DataTable.defaults.language.paginate.next\n         *\n         *  @example\n         *    $(document).ready( function() {\n         *      $('#example').dataTable( {\n         *        \"language\": {\n         *          \"paginate\": {\n         *            \"next\": \"Next page\"\n         *          }\n         *        }\n         *      } );\n         *    } );\n         */\n        \"sNext\": \"Next\",\n\n        /**\n         * Text to use for the 'previous' pagination button (to take the user to\n         * the previous page).\n         *  @type string\n         *  @default Previous\n         *\n         *  @dtopt Language\n         *  @name DataTable.defaults.language.paginate.previous\n         *\n         *  @example\n         *    $(document).ready( function() {\n         *      $('#example').dataTable( {\n         *        \"language\": {\n         *          \"paginate\": {\n         *            \"previous\": \"Previous page\"\n         *          }\n         *        }\n         *      } );\n         *    } );\n         */\n        \"sPrevious\": \"Previous\"\n      },\n\n      /**\n       * This string is shown in preference to `zeroRecords` when the table is\n       * empty of data (regardless of filtering). Note that this is an optional\n       * parameter - if it is not given, the value of `zeroRecords` will be used\n       * instead (either the default or given value).\n       *  @type string\n       *  @default No data available in table\n       *\n       *  @dtopt Language\n       *  @name DataTable.defaults.language.emptyTable\n       *\n       *  @example\n       *    $(document).ready( function() {\n       *      $('#example').dataTable( {\n       *        \"language\": {\n       *          \"emptyTable\": \"No data available in table\"\n       *        }\n       *      } );\n       *    } );\n       */\n      \"sEmptyTable\": \"No data available in table\",\n\n      /**\n       * This string gives information to the end user about the information\n       * that is current on display on the page. The following tokens can be\n       * used in the string and will be dynamically replaced as the table\n       * display updates. This tokens can be placed anywhere in the string, or\n       * removed as needed by the language requires:\n       *\n       * * `\\_START\\_` - Display index of the first record on the current page\n       * * `\\_END\\_` - Display index of the last record on the current page\n       * * `\\_TOTAL\\_` - Number of records in the table after filtering\n       * * `\\_MAX\\_` - Number of records in the table without filtering\n       * * `\\_PAGE\\_` - Current page number\n       * * `\\_PAGES\\_` - Total number of pages of data in the table\n       *\n       *  @type string\n       *  @default Showing _START_ to _END_ of _TOTAL_ entries\n       *\n       *  @dtopt Language\n       *  @name DataTable.defaults.language.info\n       *\n       *  @example\n       *    $(document).ready( function() {\n       *      $('#example').dataTable( {\n       *        \"language\": {\n       *          \"info\": \"Showing page _PAGE_ of _PAGES_\"\n       *        }\n       *      } );\n       *    } );\n       */\n      \"sInfo\": \"Showing _START_ to _END_ of _TOTAL_ entries\",\n\n      /**\n       * Display information string for when the table is empty. Typically the\n       * format of this string should match `info`.\n       *  @type string\n       *  @default Showing 0 to 0 of 0 entries\n       *\n       *  @dtopt Language\n       *  @name DataTable.defaults.language.infoEmpty\n       *\n       *  @example\n       *    $(document).ready( function() {\n       *      $('#example').dataTable( {\n       *        \"language\": {\n       *          \"infoEmpty\": \"No entries to show\"\n       *        }\n       *      } );\n       *    } );\n       */\n      \"sInfoEmpty\": \"Showing 0 to 0 of 0 entries\",\n\n      /**\n       * When a user filters the information in a table, this string is appended\n       * to the information (`info`) to give an idea of how strong the filtering\n       * is. The variable _MAX_ is dynamically updated.\n       *  @type string\n       *  @default (filtered from _MAX_ total entries)\n       *\n       *  @dtopt Language\n       *  @name DataTable.defaults.language.infoFiltered\n       *\n       *  @example\n       *    $(document).ready( function() {\n       *      $('#example').dataTable( {\n       *        \"language\": {\n       *          \"infoFiltered\": \" - filtering from _MAX_ records\"\n       *        }\n       *      } );\n       *    } );\n       */\n      \"sInfoFiltered\": \"(filtered from _MAX_ total entries)\",\n\n      /**\n       * If can be useful to append extra information to the info string at times,\n       * and this variable does exactly that. This information will be appended to\n       * the `info` (`infoEmpty` and `infoFiltered` in whatever combination they are\n       * being used) at all times.\n       *  @type string\n       *  @default <i>Empty string</i>\n       *\n       *  @dtopt Language\n       *  @name DataTable.defaults.language.infoPostFix\n       *\n       *  @example\n       *    $(document).ready( function() {\n       *      $('#example').dataTable( {\n       *        \"language\": {\n       *          \"infoPostFix\": \"All records shown are derived from real information.\"\n       *        }\n       *      } );\n       *    } );\n       */\n      \"sInfoPostFix\": \"\",\n\n      /**\n       * This decimal place operator is a little different from the other\n       * language options since DataTables doesn't output floating point\n       * numbers, so it won't ever use this for display of a number. Rather,\n       * what this parameter does is modify the sort methods of the table so\n       * that numbers which are in a format which has a character other than\n       * a period (`.`) as a decimal place will be sorted numerically.\n       *\n       * Note that numbers with different decimal places cannot be shown in\n       * the same table and still be sortable, the table must be consistent.\n       * However, multiple different tables on the page can use different\n       * decimal place characters.\n       *  @type string\n       *  @default \n       *\n       *  @dtopt Language\n       *  @name DataTable.defaults.language.decimal\n       *\n       *  @example\n       *    $(document).ready( function() {\n       *      $('#example').dataTable( {\n       *        \"language\": {\n       *          \"decimal\": \",\"\n       *          \"thousands\": \".\"\n       *        }\n       *      } );\n       *    } );\n       */\n      \"sDecimal\": \"\",\n\n      /**\n       * DataTables has a build in number formatter (`formatNumber`) which is\n       * used to format large numbers that are used in the table information.\n       * By default a comma is used, but this can be trivially changed to any\n       * character you wish with this parameter.\n       *  @type string\n       *  @default ,\n       *\n       *  @dtopt Language\n       *  @name DataTable.defaults.language.thousands\n       *\n       *  @example\n       *    $(document).ready( function() {\n       *      $('#example').dataTable( {\n       *        \"language\": {\n       *          \"thousands\": \"'\"\n       *        }\n       *      } );\n       *    } );\n       */\n      \"sThousands\": \",\",\n\n      /**\n       * Detail the action that will be taken when the drop down menu for the\n       * pagination length option is changed. The '_MENU_' variable is replaced\n       * with a default select list of 10, 25, 50 and 100, and can be replaced\n       * with a custom select box if required.\n       *  @type string\n       *  @default Show _MENU_ entries\n       *\n       *  @dtopt Language\n       *  @name DataTable.defaults.language.lengthMenu\n       *\n       *  @example\n       *    // Language change only\n       *    $(document).ready( function() {\n       *      $('#example').dataTable( {\n       *        \"language\": {\n       *          \"lengthMenu\": \"Display _MENU_ records\"\n       *        }\n       *      } );\n       *    } );\n       *\n       *  @example\n       *    // Language and options change\n       *    $(document).ready( function() {\n       *      $('#example').dataTable( {\n       *        \"language\": {\n       *          \"lengthMenu\": 'Display <select>'+\n       *            '<option value=\"10\">10</option>'+\n       *            '<option value=\"20\">20</option>'+\n       *            '<option value=\"30\">30</option>'+\n       *            '<option value=\"40\">40</option>'+\n       *            '<option value=\"50\">50</option>'+\n       *            '<option value=\"-1\">All</option>'+\n       *            '</select> records'\n       *        }\n       *      } );\n       *    } );\n       */\n      \"sLengthMenu\": \"Show _MENU_ entries\",\n\n      /**\n       * When using Ajax sourced data and during the first draw when DataTables is\n       * gathering the data, this message is shown in an empty row in the table to\n       * indicate to the end user the the data is being loaded. Note that this\n       * parameter is not used when loading data by server-side processing, just\n       * Ajax sourced data with client-side processing.\n       *  @type string\n       *  @default Loading...\n       *\n       *  @dtopt Language\n       *  @name DataTable.defaults.language.loadingRecords\n       *\n       *  @example\n       *    $(document).ready( function() {\n       *      $('#example').dataTable( {\n       *        \"language\": {\n       *          \"loadingRecords\": \"Please wait - loading...\"\n       *        }\n       *      } );\n       *    } );\n       */\n      \"sLoadingRecords\": \"Loading...\",\n\n      /**\n       * Text which is displayed when the table is processing a user action\n       * (usually a sort command or similar).\n       *  @type string\n       *  @default Processing...\n       *\n       *  @dtopt Language\n       *  @name DataTable.defaults.language.processing\n       *\n       *  @example\n       *    $(document).ready( function() {\n       *      $('#example').dataTable( {\n       *        \"language\": {\n       *          \"processing\": \"DataTables is currently busy\"\n       *        }\n       *      } );\n       *    } );\n       */\n      \"sProcessing\": \"Processing...\",\n\n      /**\n       * Details the actions that will be taken when the user types into the\n       * filtering input text box. The variable \"_INPUT_\", if used in the string,\n       * is replaced with the HTML text box for the filtering input allowing\n       * control over where it appears in the string. If \"_INPUT_\" is not given\n       * then the input box is appended to the string automatically.\n       *  @type string\n       *  @default Search:\n       *\n       *  @dtopt Language\n       *  @name DataTable.defaults.language.search\n       *\n       *  @example\n       *    // Input text box will be appended at the end automatically\n       *    $(document).ready( function() {\n       *      $('#example').dataTable( {\n       *        \"language\": {\n       *          \"search\": \"Filter records:\"\n       *        }\n       *      } );\n       *    } );\n       *\n       *  @example\n       *    // Specify where the filter should appear\n       *    $(document).ready( function() {\n       *      $('#example').dataTable( {\n       *        \"language\": {\n       *          \"search\": \"Apply filter _INPUT_ to table\"\n       *        }\n       *      } );\n       *    } );\n       */\n      \"sSearch\": \"Search:\",\n\n      /**\n       * Assign a `placeholder` attribute to the search `input` element\n       *  @type string\n       *  @default \n       *\n       *  @dtopt Language\n       *  @name DataTable.defaults.language.searchPlaceholder\n       */\n      \"sSearchPlaceholder\": \"\",\n\n      /**\n       * All of the language information can be stored in a file on the\n       * server-side, which DataTables will look up if this parameter is passed.\n       * It must store the URL of the language file, which is in a JSON format,\n       * and the object has the same properties as the oLanguage object in the\n       * initialiser object (i.e. the above parameters). Please refer to one of\n       * the example language files to see how this works in action.\n       *  @type string\n       *  @default <i>Empty string - i.e. disabled</i>\n       *\n       *  @dtopt Language\n       *  @name DataTable.defaults.language.url\n       *\n       *  @example\n       *    $(document).ready( function() {\n       *      $('#example').dataTable( {\n       *        \"language\": {\n       *          \"url\": \"http://www.sprymedia.co.uk/dataTables/lang.txt\"\n       *        }\n       *      } );\n       *    } );\n       */\n      \"sUrl\": \"\",\n\n      /**\n       * Text shown inside the table records when the is no information to be\n       * displayed after filtering. `emptyTable` is shown when there is simply no\n       * information in the table at all (regardless of filtering).\n       *  @type string\n       *  @default No matching records found\n       *\n       *  @dtopt Language\n       *  @name DataTable.defaults.language.zeroRecords\n       *\n       *  @example\n       *    $(document).ready( function() {\n       *      $('#example').dataTable( {\n       *        \"language\": {\n       *          \"zeroRecords\": \"No records to display\"\n       *        }\n       *      } );\n       *    } );\n       */\n      \"sZeroRecords\": \"No matching records found\"\n    },\n\n    /**\n     * This parameter allows you to have define the global filtering state at\n     * initialisation time. As an object the `search` parameter must be\n     * defined, but all other parameters are optional. When `regex` is true,\n     * the search string will be treated as a regular expression, when false\n     * (default) it will be treated as a straight string. When `smart`\n     * DataTables will use it's smart filtering methods (to word match at\n     * any point in the data), when false this will not be done.\n     *  @namespace\n     *  @extends DataTable.models.oSearch\n     *\n     *  @dtopt Options\n     *  @name DataTable.defaults.search\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"search\": {\"search\": \"Initial search\"}\n     *      } );\n     *    } )\n     */\n    \"oSearch\": $.extend({}, DataTable.models.oSearch),\n\n    /**\n     * __Deprecated__ The functionality provided by this parameter has now been\n     * superseded by that provided through `ajax`, which should be used instead.\n     *\n     * By default DataTables will look for the property `data` (or `aaData` for\n     * compatibility with DataTables 1.9-) when obtaining data from an Ajax\n     * source or for server-side processing - this parameter allows that\n     * property to be changed. You can use Javascript dotted object notation to\n     * get a data source for multiple levels of nesting.\n     *  @type string\n     *  @default data\n     *\n     *  @dtopt Options\n     *  @dtopt Server-side\n     *  @name DataTable.defaults.ajaxDataProp\n     *\n     *  @deprecated 1.10. Please use `ajax` for this functionality now.\n     */\n    \"sAjaxDataProp\": \"data\",\n\n    /**\n     * __Deprecated__ The functionality provided by this parameter has now been\n     * superseded by that provided through `ajax`, which should be used instead.\n     *\n     * You can instruct DataTables to load data from an external\n     * source using this parameter (use aData if you want to pass data in you\n     * already have). Simply provide a url a JSON object can be obtained from.\n     *  @type string\n     *  @default null\n     *\n     *  @dtopt Options\n     *  @dtopt Server-side\n     *  @name DataTable.defaults.ajaxSource\n     *\n     *  @deprecated 1.10. Please use `ajax` for this functionality now.\n     */\n    \"sAjaxSource\": null,\n\n    /**\n     * This initialisation variable allows you to specify exactly where in the\n     * DOM you want DataTables to inject the various controls it adds to the page\n     * (for example you might want the pagination controls at the top of the\n     * table). DIV elements (with or without a custom class) can also be added to\n     * aid styling. The follow syntax is used:\n     *   <ul>\n     *     <li>The following options are allowed:\n     *       <ul>\n     *         <li>'l' - Length changing</li>\n     *         <li>'f' - Filtering input</li>\n     *         <li>'t' - The table!</li>\n     *         <li>'i' - Information</li>\n     *         <li>'p' - Pagination</li>\n     *         <li>'r' - pRocessing</li>\n     *       </ul>\n     *     </li>\n     *     <li>The following constants are allowed:\n     *       <ul>\n     *         <li>'H' - jQueryUI theme \"header\" classes ('fg-toolbar ui-widget-header ui-corner-tl ui-corner-tr ui-helper-clearfix')</li>\n     *         <li>'F' - jQueryUI theme \"footer\" classes ('fg-toolbar ui-widget-header ui-corner-bl ui-corner-br ui-helper-clearfix')</li>\n     *       </ul>\n     *     </li>\n     *     <li>The following syntax is expected:\n     *       <ul>\n     *         <li>'&lt;' and '&gt;' - div elements</li>\n     *         <li>'&lt;\"class\" and '&gt;' - div with a class</li>\n     *         <li>'&lt;\"#id\" and '&gt;' - div with an ID</li>\n     *       </ul>\n     *     </li>\n     *     <li>Examples:\n     *       <ul>\n     *         <li>'&lt;\"wrapper\"flipt&gt;'</li>\n     *         <li>'&lt;lf&lt;t&gt;ip&gt;'</li>\n     *       </ul>\n     *     </li>\n     *   </ul>\n     *  @type string\n     *  @default lfrtip <i>(when `jQueryUI` is false)</i> <b>or</b>\n     *    <\"H\"lfr>t<\"F\"ip> <i>(when `jQueryUI` is true)</i>\n     *\n     *  @dtopt Options\n     *  @name DataTable.defaults.dom\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"dom\": '&lt;\"top\"i&gt;rt&lt;\"bottom\"flp&gt;&lt;\"clear\"&gt;'\n     *      } );\n     *    } );\n     */\n    \"sDom\": \"lfrtip\",\n\n    /**\n     * Search delay option. This will throttle full table searches that use the\n     * DataTables provided search input element (it does not effect calls to\n     * `dt-api search()`, providing a delay before the search is made.\n     *  @type integer\n     *  @default 0\n     *\n     *  @dtopt Options\n     *  @name DataTable.defaults.searchDelay\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"searchDelay\": 200\n     *      } );\n     *    } )\n     */\n    \"searchDelay\": null,\n\n    /**\n     * DataTables features six different built-in options for the buttons to\n     * display for pagination control:\n     *\n     * * `numbers` - Page number buttons only\n     * * `simple` - 'Previous' and 'Next' buttons only\n     * * 'simple_numbers` - 'Previous' and 'Next' buttons, plus page numbers\n     * * `full` - 'First', 'Previous', 'Next' and 'Last' buttons\n     * * `full_numbers` - 'First', 'Previous', 'Next' and 'Last' buttons, plus page numbers\n     * * `first_last_numbers` - 'First' and 'Last' buttons, plus page numbers\n     *  \n     * Further methods can be added using {@link DataTable.ext.oPagination}.\n     *  @type string\n     *  @default simple_numbers\n     *\n     *  @dtopt Options\n     *  @name DataTable.defaults.pagingType\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"pagingType\": \"full_numbers\"\n     *      } );\n     *    } )\n     */\n    \"sPaginationType\": \"simple_numbers\",\n\n    /**\n     * Enable horizontal scrolling. When a table is too wide to fit into a\n     * certain layout, or you have a large number of columns in the table, you\n     * can enable x-scrolling to show the table in a viewport, which can be\n     * scrolled. This property can be `true` which will allow the table to\n     * scroll horizontally when needed, or any CSS unit, or a number (in which\n     * case it will be treated as a pixel measurement). Setting as simply `true`\n     * is recommended.\n     *  @type boolean|string\n     *  @default <i>blank string - i.e. disabled</i>\n     *\n     *  @dtopt Features\n     *  @name DataTable.defaults.scrollX\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"scrollX\": true,\n     *        \"scrollCollapse\": true\n     *      } );\n     *    } );\n     */\n    \"sScrollX\": \"\",\n\n    /**\n     * This property can be used to force a DataTable to use more width than it\n     * might otherwise do when x-scrolling is enabled. For example if you have a\n     * table which requires to be well spaced, this parameter is useful for\n     * \"over-sizing\" the table, and thus forcing scrolling. This property can by\n     * any CSS unit, or a number (in which case it will be treated as a pixel\n     * measurement).\n     *  @type string\n     *  @default <i>blank string - i.e. disabled</i>\n     *\n     *  @dtopt Options\n     *  @name DataTable.defaults.scrollXInner\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"scrollX\": \"100%\",\n     *        \"scrollXInner\": \"110%\"\n     *      } );\n     *    } );\n     */\n    \"sScrollXInner\": \"\",\n\n    /**\n     * Enable vertical scrolling. Vertical scrolling will constrain the DataTable\n     * to the given height, and enable scrolling for any data which overflows the\n     * current viewport. This can be used as an alternative to paging to display\n     * a lot of data in a small area (although paging and scrolling can both be\n     * enabled at the same time). This property can be any CSS unit, or a number\n     * (in which case it will be treated as a pixel measurement).\n     *  @type string\n     *  @default <i>blank string - i.e. disabled</i>\n     *\n     *  @dtopt Features\n     *  @name DataTable.defaults.scrollY\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"scrollY\": \"200px\",\n     *        \"paginate\": false\n     *      } );\n     *    } );\n     */\n    \"sScrollY\": \"\",\n\n    /**\n     * __Deprecated__ The functionality provided by this parameter has now been\n     * superseded by that provided through `ajax`, which should be used instead.\n     *\n     * Set the HTTP method that is used to make the Ajax call for server-side\n     * processing or Ajax sourced data.\n     *  @type string\n     *  @default GET\n     *\n     *  @dtopt Options\n     *  @dtopt Server-side\n     *  @name DataTable.defaults.serverMethod\n     *\n     *  @deprecated 1.10. Please use `ajax` for this functionality now.\n     */\n    \"sServerMethod\": \"GET\",\n\n    /**\n     * DataTables makes use of renderers when displaying HTML elements for\n     * a table. These renderers can be added or modified by plug-ins to\n     * generate suitable mark-up for a site. For example the Bootstrap\n     * integration plug-in for DataTables uses a paging button renderer to\n     * display pagination buttons in the mark-up required by Bootstrap.\n     *\n     * For further information about the renderers available see\n     * DataTable.ext.renderer\n     *  @type string|object\n     *  @default null\n     *\n     *  @name DataTable.defaults.renderer\n     *\n     */\n    \"renderer\": null,\n\n    /**\n     * Set the data property name that DataTables should use to get a row's id\n     * to set as the `id` property in the node.\n     *  @type string\n     *  @default DT_RowId\n     *\n     *  @name DataTable.defaults.rowId\n     */\n    \"rowId\": \"DT_RowId\"\n  };\n\n  _fnHungarianMap(DataTable.defaults);\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   */\n\n\n  DataTable.defaults.column = {\n    /**\n     * Define which column(s) an order will occur on for this column. This\n     * allows a column's ordering to take multiple columns into account when\n     * doing a sort or use the data from a different column. For example first\n     * name / last name columns make sense to do a multi-column sort over the\n     * two columns.\n     *  @type array|int\n     *  @default null <i>Takes the value of the column index automatically</i>\n     *\n     *  @name DataTable.defaults.column.orderData\n     *  @dtopt Columns\n     *\n     *  @example\n     *    // Using `columnDefs`\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columnDefs\": [\n     *          { \"orderData\": [ 0, 1 ], \"targets\": [ 0 ] },\n     *          { \"orderData\": [ 1, 0 ], \"targets\": [ 1 ] },\n     *          { \"orderData\": 2, \"targets\": [ 2 ] }\n     *        ]\n     *      } );\n     *    } );\n     *\n     *  @example\n     *    // Using `columns`\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columns\": [\n     *          { \"orderData\": [ 0, 1 ] },\n     *          { \"orderData\": [ 1, 0 ] },\n     *          { \"orderData\": 2 },\n     *          null,\n     *          null\n     *        ]\n     *      } );\n     *    } );\n     */\n    \"aDataSort\": null,\n    \"iDataSort\": -1,\n\n    /**\n     * You can control the default ordering direction, and even alter the\n     * behaviour of the sort handler (i.e. only allow ascending ordering etc)\n     * using this parameter.\n     *  @type array\n     *  @default [ 'asc', 'desc' ]\n     *\n     *  @name DataTable.defaults.column.orderSequence\n     *  @dtopt Columns\n     *\n     *  @example\n     *    // Using `columnDefs`\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columnDefs\": [\n     *          { \"orderSequence\": [ \"asc\" ], \"targets\": [ 1 ] },\n     *          { \"orderSequence\": [ \"desc\", \"asc\", \"asc\" ], \"targets\": [ 2 ] },\n     *          { \"orderSequence\": [ \"desc\" ], \"targets\": [ 3 ] }\n     *        ]\n     *      } );\n     *    } );\n     *\n     *  @example\n     *    // Using `columns`\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columns\": [\n     *          null,\n     *          { \"orderSequence\": [ \"asc\" ] },\n     *          { \"orderSequence\": [ \"desc\", \"asc\", \"asc\" ] },\n     *          { \"orderSequence\": [ \"desc\" ] },\n     *          null\n     *        ]\n     *      } );\n     *    } );\n     */\n    \"asSorting\": ['asc', 'desc'],\n\n    /**\n     * Enable or disable filtering on the data in this column.\n     *  @type boolean\n     *  @default true\n     *\n     *  @name DataTable.defaults.column.searchable\n     *  @dtopt Columns\n     *\n     *  @example\n     *    // Using `columnDefs`\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columnDefs\": [\n     *          { \"searchable\": false, \"targets\": [ 0 ] }\n     *        ] } );\n     *    } );\n     *\n     *  @example\n     *    // Using `columns`\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columns\": [\n     *          { \"searchable\": false },\n     *          null,\n     *          null,\n     *          null,\n     *          null\n     *        ] } );\n     *    } );\n     */\n    \"bSearchable\": true,\n\n    /**\n     * Enable or disable ordering on this column.\n     *  @type boolean\n     *  @default true\n     *\n     *  @name DataTable.defaults.column.orderable\n     *  @dtopt Columns\n     *\n     *  @example\n     *    // Using `columnDefs`\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columnDefs\": [\n     *          { \"orderable\": false, \"targets\": [ 0 ] }\n     *        ] } );\n     *    } );\n     *\n     *  @example\n     *    // Using `columns`\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columns\": [\n     *          { \"orderable\": false },\n     *          null,\n     *          null,\n     *          null,\n     *          null\n     *        ] } );\n     *    } );\n     */\n    \"bSortable\": true,\n\n    /**\n     * Enable or disable the display of this column.\n     *  @type boolean\n     *  @default true\n     *\n     *  @name DataTable.defaults.column.visible\n     *  @dtopt Columns\n     *\n     *  @example\n     *    // Using `columnDefs`\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columnDefs\": [\n     *          { \"visible\": false, \"targets\": [ 0 ] }\n     *        ] } );\n     *    } );\n     *\n     *  @example\n     *    // Using `columns`\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columns\": [\n     *          { \"visible\": false },\n     *          null,\n     *          null,\n     *          null,\n     *          null\n     *        ] } );\n     *    } );\n     */\n    \"bVisible\": true,\n\n    /**\n     * Developer definable function that is called whenever a cell is created (Ajax source,\n     * etc) or processed for input (DOM source). This can be used as a compliment to mRender\n     * allowing you to modify the DOM element (add background colour for example) when the\n     * element is available.\n     *  @type function\n     *  @param {element} td The TD node that has been created\n     *  @param {*} cellData The Data for the cell\n     *  @param {array|object} rowData The data for the whole row\n     *  @param {int} row The row index for the aoData data store\n     *  @param {int} col The column index for aoColumns\n     *\n     *  @name DataTable.defaults.column.createdCell\n     *  @dtopt Columns\n     *\n     *  @example\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columnDefs\": [ {\n     *          \"targets\": [3],\n     *          \"createdCell\": function (td, cellData, rowData, row, col) {\n     *            if ( cellData == \"1.7\" ) {\n     *              $(td).css('color', 'blue')\n     *            }\n     *          }\n     *        } ]\n     *      });\n     *    } );\n     */\n    \"fnCreatedCell\": null,\n\n    /**\n     * This parameter has been replaced by `data` in DataTables to ensure naming\n     * consistency. `dataProp` can still be used, as there is backwards\n     * compatibility in DataTables for this option, but it is strongly\n     * recommended that you use `data` in preference to `dataProp`.\n     *  @name DataTable.defaults.column.dataProp\n     */\n\n    /**\n     * This property can be used to read data from any data source property,\n     * including deeply nested objects / properties. `data` can be given in a\n     * number of different ways which effect its behaviour:\n     *\n     * * `integer` - treated as an array index for the data source. This is the\n     *   default that DataTables uses (incrementally increased for each column).\n     * * `string` - read an object property from the data source. There are\n     *   three 'special' options that can be used in the string to alter how\n     *   DataTables reads the data from the source object:\n     *    * `.` - Dotted Javascript notation. Just as you use a `.` in\n     *      Javascript to read from nested objects, so to can the options\n     *      specified in `data`. For example: `browser.version` or\n     *      `browser.name`. If your object parameter name contains a period, use\n     *      `\\\\` to escape it - i.e. `first\\\\.name`.\n     *    * `[]` - Array notation. DataTables can automatically combine data\n     *      from and array source, joining the data with the characters provided\n     *      between the two brackets. For example: `name[, ]` would provide a\n     *      comma-space separated list from the source array. If no characters\n     *      are provided between the brackets, the original array source is\n     *      returned.\n     *    * `()` - Function notation. Adding `()` to the end of a parameter will\n     *      execute a function of the name given. For example: `browser()` for a\n     *      simple function on the data source, `browser.version()` for a\n     *      function in a nested property or even `browser().version` to get an\n     *      object property if the function called returns an object. Note that\n     *      function notation is recommended for use in `render` rather than\n     *      `data` as it is much simpler to use as a renderer.\n     * * `null` - use the original data source for the row rather than plucking\n     *   data directly from it. This action has effects on two other\n     *   initialisation options:\n     *    * `defaultContent` - When null is given as the `data` option and\n     *      `defaultContent` is specified for the column, the value defined by\n     *      `defaultContent` will be used for the cell.\n     *    * `render` - When null is used for the `data` option and the `render`\n     *      option is specified for the column, the whole data source for the\n     *      row is used for the renderer.\n     * * `function` - the function given will be executed whenever DataTables\n     *   needs to set or get the data for a cell in the column. The function\n     *   takes three parameters:\n     *    * Parameters:\n     *      * `{array|object}` The data source for the row\n     *      * `{string}` The type call data requested - this will be 'set' when\n     *        setting data or 'filter', 'display', 'type', 'sort' or undefined\n     *        when gathering data. Note that when `undefined` is given for the\n     *        type DataTables expects to get the raw data for the object back<\n     *      * `{*}` Data to set when the second parameter is 'set'.\n     *    * Return:\n     *      * The return value from the function is not required when 'set' is\n     *        the type of call, but otherwise the return is what will be used\n     *        for the data requested.\n     *\n     * Note that `data` is a getter and setter option. If you just require\n     * formatting of data for output, you will likely want to use `render` which\n     * is simply a getter and thus simpler to use.\n     *\n     * Note that prior to DataTables 1.9.2 `data` was called `mDataProp`. The\n     * name change reflects the flexibility of this property and is consistent\n     * with the naming of mRender. If 'mDataProp' is given, then it will still\n     * be used by DataTables, as it automatically maps the old name to the new\n     * if required.\n     *\n     *  @type string|int|function|null\n     *  @default null <i>Use automatically calculated column index</i>\n     *\n     *  @name DataTable.defaults.column.data\n     *  @dtopt Columns\n     *\n     *  @example\n     *    // Read table data from objects\n     *    // JSON structure for each row:\n     *    //   {\n     *    //      \"engine\": {value},\n     *    //      \"browser\": {value},\n     *    //      \"platform\": {value},\n     *    //      \"version\": {value},\n     *    //      \"grade\": {value}\n     *    //   }\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"ajaxSource\": \"sources/objects.txt\",\n     *        \"columns\": [\n     *          { \"data\": \"engine\" },\n     *          { \"data\": \"browser\" },\n     *          { \"data\": \"platform\" },\n     *          { \"data\": \"version\" },\n     *          { \"data\": \"grade\" }\n     *        ]\n     *      } );\n     *    } );\n     *\n     *  @example\n     *    // Read information from deeply nested objects\n     *    // JSON structure for each row:\n     *    //   {\n     *    //      \"engine\": {value},\n     *    //      \"browser\": {value},\n     *    //      \"platform\": {\n     *    //         \"inner\": {value}\n     *    //      },\n     *    //      \"details\": [\n     *    //         {value}, {value}\n     *    //      ]\n     *    //   }\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"ajaxSource\": \"sources/deep.txt\",\n     *        \"columns\": [\n     *          { \"data\": \"engine\" },\n     *          { \"data\": \"browser\" },\n     *          { \"data\": \"platform.inner\" },\n     *          { \"data\": \"details.0\" },\n     *          { \"data\": \"details.1\" }\n     *        ]\n     *      } );\n     *    } );\n     *\n     *  @example\n     *    // Using `data` as a function to provide different information for\n     *    // sorting, filtering and display. In this case, currency (price)\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columnDefs\": [ {\n     *          \"targets\": [ 0 ],\n     *          \"data\": function ( source, type, val ) {\n     *            if (type === 'set') {\n     *              source.price = val;\n     *              // Store the computed dislay and filter values for efficiency\n     *              source.price_display = val==\"\" ? \"\" : \"$\"+numberFormat(val);\n     *              source.price_filter  = val==\"\" ? \"\" : \"$\"+numberFormat(val)+\" \"+val;\n     *              return;\n     *            }\n     *            else if (type === 'display') {\n     *              return source.price_display;\n     *            }\n     *            else if (type === 'filter') {\n     *              return source.price_filter;\n     *            }\n     *            // 'sort', 'type' and undefined all just use the integer\n     *            return source.price;\n     *          }\n     *        } ]\n     *      } );\n     *    } );\n     *\n     *  @example\n     *    // Using default content\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columnDefs\": [ {\n     *          \"targets\": [ 0 ],\n     *          \"data\": null,\n     *          \"defaultContent\": \"Click to edit\"\n     *        } ]\n     *      } );\n     *    } );\n     *\n     *  @example\n     *    // Using array notation - outputting a list from an array\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columnDefs\": [ {\n     *          \"targets\": [ 0 ],\n     *          \"data\": \"name[, ]\"\n     *        } ]\n     *      } );\n     *    } );\n     *\n     */\n    \"mData\": null,\n\n    /**\n     * This property is the rendering partner to `data` and it is suggested that\n     * when you want to manipulate data for display (including filtering,\n     * sorting etc) without altering the underlying data for the table, use this\n     * property. `render` can be considered to be the the read only companion to\n     * `data` which is read / write (then as such more complex). Like `data`\n     * this option can be given in a number of different ways to effect its\n     * behaviour:\n     *\n     * * `integer` - treated as an array index for the data source. This is the\n     *   default that DataTables uses (incrementally increased for each column).\n     * * `string` - read an object property from the data source. There are\n     *   three 'special' options that can be used in the string to alter how\n     *   DataTables reads the data from the source object:\n     *    * `.` - Dotted Javascript notation. Just as you use a `.` in\n     *      Javascript to read from nested objects, so to can the options\n     *      specified in `data`. For example: `browser.version` or\n     *      `browser.name`. If your object parameter name contains a period, use\n     *      `\\\\` to escape it - i.e. `first\\\\.name`.\n     *    * `[]` - Array notation. DataTables can automatically combine data\n     *      from and array source, joining the data with the characters provided\n     *      between the two brackets. For example: `name[, ]` would provide a\n     *      comma-space separated list from the source array. If no characters\n     *      are provided between the brackets, the original array source is\n     *      returned.\n     *    * `()` - Function notation. Adding `()` to the end of a parameter will\n     *      execute a function of the name given. For example: `browser()` for a\n     *      simple function on the data source, `browser.version()` for a\n     *      function in a nested property or even `browser().version` to get an\n     *      object property if the function called returns an object.\n     * * `object` - use different data for the different data types requested by\n     *   DataTables ('filter', 'display', 'type' or 'sort'). The property names\n     *   of the object is the data type the property refers to and the value can\n     *   defined using an integer, string or function using the same rules as\n     *   `render` normally does. Note that an `_` option _must_ be specified.\n     *   This is the default value to use if you haven't specified a value for\n     *   the data type requested by DataTables.\n     * * `function` - the function given will be executed whenever DataTables\n     *   needs to set or get the data for a cell in the column. The function\n     *   takes three parameters:\n     *    * Parameters:\n     *      * {array|object} The data source for the row (based on `data`)\n     *      * {string} The type call data requested - this will be 'filter',\n     *        'display', 'type' or 'sort'.\n     *      * {array|object} The full data source for the row (not based on\n     *        `data`)\n     *    * Return:\n     *      * The return value from the function is what will be used for the\n     *        data requested.\n     *\n     *  @type string|int|function|object|null\n     *  @default null Use the data source value.\n     *\n     *  @name DataTable.defaults.column.render\n     *  @dtopt Columns\n     *\n     *  @example\n     *    // Create a comma separated list from an array of objects\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"ajaxSource\": \"sources/deep.txt\",\n     *        \"columns\": [\n     *          { \"data\": \"engine\" },\n     *          { \"data\": \"browser\" },\n     *          {\n     *            \"data\": \"platform\",\n     *            \"render\": \"[, ].name\"\n     *          }\n     *        ]\n     *      } );\n     *    } );\n     *\n     *  @example\n     *    // Execute a function to obtain data\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columnDefs\": [ {\n     *          \"targets\": [ 0 ],\n     *          \"data\": null, // Use the full data source object for the renderer's source\n     *          \"render\": \"browserName()\"\n     *        } ]\n     *      } );\n     *    } );\n     *\n     *  @example\n     *    // As an object, extracting different data for the different types\n     *    // This would be used with a data source such as:\n     *    //   { \"phone\": 5552368, \"phone_filter\": \"5552368 555-2368\", \"phone_display\": \"555-2368\" }\n     *    // Here the `phone` integer is used for sorting and type detection, while `phone_filter`\n     *    // (which has both forms) is used for filtering for if a user inputs either format, while\n     *    // the formatted phone number is the one that is shown in the table.\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columnDefs\": [ {\n     *          \"targets\": [ 0 ],\n     *          \"data\": null, // Use the full data source object for the renderer's source\n     *          \"render\": {\n     *            \"_\": \"phone\",\n     *            \"filter\": \"phone_filter\",\n     *            \"display\": \"phone_display\"\n     *          }\n     *        } ]\n     *      } );\n     *    } );\n     *\n     *  @example\n     *    // Use as a function to create a link from the data source\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columnDefs\": [ {\n     *          \"targets\": [ 0 ],\n     *          \"data\": \"download_link\",\n     *          \"render\": function ( data, type, full ) {\n     *            return '<a href=\"'+data+'\">Download</a>';\n     *          }\n     *        } ]\n     *      } );\n     *    } );\n     */\n    \"mRender\": null,\n\n    /**\n     * Change the cell type created for the column - either TD cells or TH cells. This\n     * can be useful as TH cells have semantic meaning in the table body, allowing them\n     * to act as a header for a row (you may wish to add scope='row' to the TH elements).\n     *  @type string\n     *  @default td\n     *\n     *  @name DataTable.defaults.column.cellType\n     *  @dtopt Columns\n     *\n     *  @example\n     *    // Make the first column use TH cells\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columnDefs\": [ {\n     *          \"targets\": [ 0 ],\n     *          \"cellType\": \"th\"\n     *        } ]\n     *      } );\n     *    } );\n     */\n    \"sCellType\": \"td\",\n\n    /**\n     * Class to give to each cell in this column.\n     *  @type string\n     *  @default <i>Empty string</i>\n     *\n     *  @name DataTable.defaults.column.class\n     *  @dtopt Columns\n     *\n     *  @example\n     *    // Using `columnDefs`\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columnDefs\": [\n     *          { \"class\": \"my_class\", \"targets\": [ 0 ] }\n     *        ]\n     *      } );\n     *    } );\n     *\n     *  @example\n     *    // Using `columns`\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columns\": [\n     *          { \"class\": \"my_class\" },\n     *          null,\n     *          null,\n     *          null,\n     *          null\n     *        ]\n     *      } );\n     *    } );\n     */\n    \"sClass\": \"\",\n\n    /**\n     * When DataTables calculates the column widths to assign to each column,\n     * it finds the longest string in each column and then constructs a\n     * temporary table and reads the widths from that. The problem with this\n     * is that \"mmm\" is much wider then \"iiii\", but the latter is a longer\n     * string - thus the calculation can go wrong (doing it properly and putting\n     * it into an DOM object and measuring that is horribly(!) slow). Thus as\n     * a \"work around\" we provide this option. It will append its value to the\n     * text that is found to be the longest string for the column - i.e. padding.\n     * Generally you shouldn't need this!\n     *  @type string\n     *  @default <i>Empty string<i>\n     *\n     *  @name DataTable.defaults.column.contentPadding\n     *  @dtopt Columns\n     *\n     *  @example\n     *    // Using `columns`\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columns\": [\n     *          null,\n     *          null,\n     *          null,\n     *          {\n     *            \"contentPadding\": \"mmm\"\n     *          }\n     *        ]\n     *      } );\n     *    } );\n     */\n    \"sContentPadding\": \"\",\n\n    /**\n     * Allows a default value to be given for a column's data, and will be used\n     * whenever a null data source is encountered (this can be because `data`\n     * is set to null, or because the data source itself is null).\n     *  @type string\n     *  @default null\n     *\n     *  @name DataTable.defaults.column.defaultContent\n     *  @dtopt Columns\n     *\n     *  @example\n     *    // Using `columnDefs`\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columnDefs\": [\n     *          {\n     *            \"data\": null,\n     *            \"defaultContent\": \"Edit\",\n     *            \"targets\": [ -1 ]\n     *          }\n     *        ]\n     *      } );\n     *    } );\n     *\n     *  @example\n     *    // Using `columns`\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columns\": [\n     *          null,\n     *          null,\n     *          null,\n     *          {\n     *            \"data\": null,\n     *            \"defaultContent\": \"Edit\"\n     *          }\n     *        ]\n     *      } );\n     *    } );\n     */\n    \"sDefaultContent\": null,\n\n    /**\n     * This parameter is only used in DataTables' server-side processing. It can\n     * be exceptionally useful to know what columns are being displayed on the\n     * client side, and to map these to database fields. When defined, the names\n     * also allow DataTables to reorder information from the server if it comes\n     * back in an unexpected order (i.e. if you switch your columns around on the\n     * client-side, your server-side code does not also need updating).\n     *  @type string\n     *  @default <i>Empty string</i>\n     *\n     *  @name DataTable.defaults.column.name\n     *  @dtopt Columns\n     *\n     *  @example\n     *    // Using `columnDefs`\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columnDefs\": [\n     *          { \"name\": \"engine\", \"targets\": [ 0 ] },\n     *          { \"name\": \"browser\", \"targets\": [ 1 ] },\n     *          { \"name\": \"platform\", \"targets\": [ 2 ] },\n     *          { \"name\": \"version\", \"targets\": [ 3 ] },\n     *          { \"name\": \"grade\", \"targets\": [ 4 ] }\n     *        ]\n     *      } );\n     *    } );\n     *\n     *  @example\n     *    // Using `columns`\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columns\": [\n     *          { \"name\": \"engine\" },\n     *          { \"name\": \"browser\" },\n     *          { \"name\": \"platform\" },\n     *          { \"name\": \"version\" },\n     *          { \"name\": \"grade\" }\n     *        ]\n     *      } );\n     *    } );\n     */\n    \"sName\": \"\",\n\n    /**\n     * Defines a data source type for the ordering which can be used to read\n     * real-time information from the table (updating the internally cached\n     * version) prior to ordering. This allows ordering to occur on user\n     * editable elements such as form inputs.\n     *  @type string\n     *  @default std\n     *\n     *  @name DataTable.defaults.column.orderDataType\n     *  @dtopt Columns\n     *\n     *  @example\n     *    // Using `columnDefs`\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columnDefs\": [\n     *          { \"orderDataType\": \"dom-text\", \"targets\": [ 2, 3 ] },\n     *          { \"type\": \"numeric\", \"targets\": [ 3 ] },\n     *          { \"orderDataType\": \"dom-select\", \"targets\": [ 4 ] },\n     *          { \"orderDataType\": \"dom-checkbox\", \"targets\": [ 5 ] }\n     *        ]\n     *      } );\n     *    } );\n     *\n     *  @example\n     *    // Using `columns`\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columns\": [\n     *          null,\n     *          null,\n     *          { \"orderDataType\": \"dom-text\" },\n     *          { \"orderDataType\": \"dom-text\", \"type\": \"numeric\" },\n     *          { \"orderDataType\": \"dom-select\" },\n     *          { \"orderDataType\": \"dom-checkbox\" }\n     *        ]\n     *      } );\n     *    } );\n     */\n    \"sSortDataType\": \"std\",\n\n    /**\n     * The title of this column.\n     *  @type string\n     *  @default null <i>Derived from the 'TH' value for this column in the\n     *    original HTML table.</i>\n     *\n     *  @name DataTable.defaults.column.title\n     *  @dtopt Columns\n     *\n     *  @example\n     *    // Using `columnDefs`\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columnDefs\": [\n     *          { \"title\": \"My column title\", \"targets\": [ 0 ] }\n     *        ]\n     *      } );\n     *    } );\n     *\n     *  @example\n     *    // Using `columns`\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columns\": [\n     *          { \"title\": \"My column title\" },\n     *          null,\n     *          null,\n     *          null,\n     *          null\n     *        ]\n     *      } );\n     *    } );\n     */\n    \"sTitle\": null,\n\n    /**\n     * The type allows you to specify how the data for this column will be\n     * ordered. Four types (string, numeric, date and html (which will strip\n     * HTML tags before ordering)) are currently available. Note that only date\n     * formats understood by Javascript's Date() object will be accepted as type\n     * date. For example: \"Mar 26, 2008 5:03 PM\". May take the values: 'string',\n     * 'numeric', 'date' or 'html' (by default). Further types can be adding\n     * through plug-ins.\n     *  @type string\n     *  @default null <i>Auto-detected from raw data</i>\n     *\n     *  @name DataTable.defaults.column.type\n     *  @dtopt Columns\n     *\n     *  @example\n     *    // Using `columnDefs`\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columnDefs\": [\n     *          { \"type\": \"html\", \"targets\": [ 0 ] }\n     *        ]\n     *      } );\n     *    } );\n     *\n     *  @example\n     *    // Using `columns`\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columns\": [\n     *          { \"type\": \"html\" },\n     *          null,\n     *          null,\n     *          null,\n     *          null\n     *        ]\n     *      } );\n     *    } );\n     */\n    \"sType\": null,\n\n    /**\n     * Defining the width of the column, this parameter may take any CSS value\n     * (3em, 20px etc). DataTables applies 'smart' widths to columns which have not\n     * been given a specific width through this interface ensuring that the table\n     * remains readable.\n     *  @type string\n     *  @default null <i>Automatic</i>\n     *\n     *  @name DataTable.defaults.column.width\n     *  @dtopt Columns\n     *\n     *  @example\n     *    // Using `columnDefs`\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columnDefs\": [\n     *          { \"width\": \"20%\", \"targets\": [ 0 ] }\n     *        ]\n     *      } );\n     *    } );\n     *\n     *  @example\n     *    // Using `columns`\n     *    $(document).ready( function() {\n     *      $('#example').dataTable( {\n     *        \"columns\": [\n     *          { \"width\": \"20%\" },\n     *          null,\n     *          null,\n     *          null,\n     *          null\n     *        ]\n     *      } );\n     *    } );\n     */\n    \"sWidth\": null\n  };\n\n  _fnHungarianMap(DataTable.defaults.column);\n  /**\n   * DataTables settings object - this holds all the information needed for a\n   * given table, including configuration, data and current application of the\n   * table options. DataTables does not have a single instance for each DataTable\n   * with the settings attached to that instance, but rather instances of the\n   * DataTable \"class\" are created on-the-fly as needed (typically by a\n   * $().dataTable() call) and the settings object is then applied to that\n   * instance.\n   *\n   * Note that this object is related to {@link DataTable.defaults} but this\n   * one is the internal data store for DataTables's cache of columns. It should\n   * NOT be manipulated outside of DataTables. Any configuration should be done\n   * through the initialisation options.\n   *  @namespace\n   *  @todo Really should attach the settings object to individual instances so we\n   *    don't need to create new instances on each $().dataTable() call (if the\n   *    table already exists). It would also save passing oSettings around and\n   *    into every single function. However, this is a very significant\n   *    architecture change for DataTables and will almost certainly break\n   *    backwards compatibility with older installations. This is something that\n   *    will be done in 2.0.\n   */\n\n\n  DataTable.models.oSettings = {\n    /**\n     * Primary features of DataTables and their enablement state.\n     *  @namespace\n     */\n    \"oFeatures\": {\n      /**\n       * Flag to say if DataTables should automatically try to calculate the\n       * optimum table and columns widths (true) or not (false).\n       * Note that this parameter will be set by the initialisation routine. To\n       * set a default use {@link DataTable.defaults}.\n       *  @type boolean\n       */\n      \"bAutoWidth\": null,\n\n      /**\n       * Delay the creation of TR and TD elements until they are actually\n       * needed by a driven page draw. This can give a significant speed\n       * increase for Ajax source and Javascript source data, but makes no\n       * difference at all fro DOM and server-side processing tables.\n       * Note that this parameter will be set by the initialisation routine. To\n       * set a default use {@link DataTable.defaults}.\n       *  @type boolean\n       */\n      \"bDeferRender\": null,\n\n      /**\n       * Enable filtering on the table or not. Note that if this is disabled\n       * then there is no filtering at all on the table, including fnFilter.\n       * To just remove the filtering input use sDom and remove the 'f' option.\n       * Note that this parameter will be set by the initialisation routine. To\n       * set a default use {@link DataTable.defaults}.\n       *  @type boolean\n       */\n      \"bFilter\": null,\n\n      /**\n       * Table information element (the 'Showing x of y records' div) enable\n       * flag.\n       * Note that this parameter will be set by the initialisation routine. To\n       * set a default use {@link DataTable.defaults}.\n       *  @type boolean\n       */\n      \"bInfo\": null,\n\n      /**\n       * Present a user control allowing the end user to change the page size\n       * when pagination is enabled.\n       * Note that this parameter will be set by the initialisation routine. To\n       * set a default use {@link DataTable.defaults}.\n       *  @type boolean\n       */\n      \"bLengthChange\": null,\n\n      /**\n       * Pagination enabled or not. Note that if this is disabled then length\n       * changing must also be disabled.\n       * Note that this parameter will be set by the initialisation routine. To\n       * set a default use {@link DataTable.defaults}.\n       *  @type boolean\n       */\n      \"bPaginate\": null,\n\n      /**\n       * Processing indicator enable flag whenever DataTables is enacting a\n       * user request - typically an Ajax request for server-side processing.\n       * Note that this parameter will be set by the initialisation routine. To\n       * set a default use {@link DataTable.defaults}.\n       *  @type boolean\n       */\n      \"bProcessing\": null,\n\n      /**\n       * Server-side processing enabled flag - when enabled DataTables will\n       * get all data from the server for every draw - there is no filtering,\n       * sorting or paging done on the client-side.\n       * Note that this parameter will be set by the initialisation routine. To\n       * set a default use {@link DataTable.defaults}.\n       *  @type boolean\n       */\n      \"bServerSide\": null,\n\n      /**\n       * Sorting enablement flag.\n       * Note that this parameter will be set by the initialisation routine. To\n       * set a default use {@link DataTable.defaults}.\n       *  @type boolean\n       */\n      \"bSort\": null,\n\n      /**\n       * Multi-column sorting\n       * Note that this parameter will be set by the initialisation routine. To\n       * set a default use {@link DataTable.defaults}.\n       *  @type boolean\n       */\n      \"bSortMulti\": null,\n\n      /**\n       * Apply a class to the columns which are being sorted to provide a\n       * visual highlight or not. This can slow things down when enabled since\n       * there is a lot of DOM interaction.\n       * Note that this parameter will be set by the initialisation routine. To\n       * set a default use {@link DataTable.defaults}.\n       *  @type boolean\n       */\n      \"bSortClasses\": null,\n\n      /**\n       * State saving enablement flag.\n       * Note that this parameter will be set by the initialisation routine. To\n       * set a default use {@link DataTable.defaults}.\n       *  @type boolean\n       */\n      \"bStateSave\": null\n    },\n\n    /**\n     * Scrolling settings for a table.\n     *  @namespace\n     */\n    \"oScroll\": {\n      /**\n       * When the table is shorter in height than sScrollY, collapse the\n       * table container down to the height of the table (when true).\n       * Note that this parameter will be set by the initialisation routine. To\n       * set a default use {@link DataTable.defaults}.\n       *  @type boolean\n       */\n      \"bCollapse\": null,\n\n      /**\n       * Width of the scrollbar for the web-browser's platform. Calculated\n       * during table initialisation.\n       *  @type int\n       *  @default 0\n       */\n      \"iBarWidth\": 0,\n\n      /**\n       * Viewport width for horizontal scrolling. Horizontal scrolling is\n       * disabled if an empty string.\n       * Note that this parameter will be set by the initialisation routine. To\n       * set a default use {@link DataTable.defaults}.\n       *  @type string\n       */\n      \"sX\": null,\n\n      /**\n       * Width to expand the table to when using x-scrolling. Typically you\n       * should not need to use this.\n       * Note that this parameter will be set by the initialisation routine. To\n       * set a default use {@link DataTable.defaults}.\n       *  @type string\n       *  @deprecated\n       */\n      \"sXInner\": null,\n\n      /**\n       * Viewport height for vertical scrolling. Vertical scrolling is disabled\n       * if an empty string.\n       * Note that this parameter will be set by the initialisation routine. To\n       * set a default use {@link DataTable.defaults}.\n       *  @type string\n       */\n      \"sY\": null\n    },\n\n    /**\n     * Language information for the table.\n     *  @namespace\n     *  @extends DataTable.defaults.oLanguage\n     */\n    \"oLanguage\": {\n      /**\n       * Information callback function. See\n       * {@link DataTable.defaults.fnInfoCallback}\n       *  @type function\n       *  @default null\n       */\n      \"fnInfoCallback\": null\n    },\n\n    /**\n     * Browser support parameters\n     *  @namespace\n     */\n    \"oBrowser\": {\n      /**\n       * Indicate if the browser incorrectly calculates width:100% inside a\n       * scrolling element (IE6/7)\n       *  @type boolean\n       *  @default false\n       */\n      \"bScrollOversize\": false,\n\n      /**\n       * Determine if the vertical scrollbar is on the right or left of the\n       * scrolling container - needed for rtl language layout, although not\n       * all browsers move the scrollbar (Safari).\n       *  @type boolean\n       *  @default false\n       */\n      \"bScrollbarLeft\": false,\n\n      /**\n       * Flag for if `getBoundingClientRect` is fully supported or not\n       *  @type boolean\n       *  @default false\n       */\n      \"bBounding\": false,\n\n      /**\n       * Browser scrollbar width\n       *  @type integer\n       *  @default 0\n       */\n      \"barWidth\": 0\n    },\n    \"ajax\": null,\n\n    /**\n     * Array referencing the nodes which are used for the features. The\n     * parameters of this object match what is allowed by sDom - i.e.\n     *   <ul>\n     *     <li>'l' - Length changing</li>\n     *     <li>'f' - Filtering input</li>\n     *     <li>'t' - The table!</li>\n     *     <li>'i' - Information</li>\n     *     <li>'p' - Pagination</li>\n     *     <li>'r' - pRocessing</li>\n     *   </ul>\n     *  @type array\n     *  @default []\n     */\n    \"aanFeatures\": [],\n\n    /**\n     * Store data information - see {@link DataTable.models.oRow} for detailed\n     * information.\n     *  @type array\n     *  @default []\n     */\n    \"aoData\": [],\n\n    /**\n     * Array of indexes which are in the current display (after filtering etc)\n     *  @type array\n     *  @default []\n     */\n    \"aiDisplay\": [],\n\n    /**\n     * Array of indexes for display - no filtering\n     *  @type array\n     *  @default []\n     */\n    \"aiDisplayMaster\": [],\n\n    /**\n     * Map of row ids to data indexes\n     *  @type object\n     *  @default {}\n     */\n    \"aIds\": {},\n\n    /**\n     * Store information about each column that is in use\n     *  @type array\n     *  @default []\n     */\n    \"aoColumns\": [],\n\n    /**\n     * Store information about the table's header\n     *  @type array\n     *  @default []\n     */\n    \"aoHeader\": [],\n\n    /**\n     * Store information about the table's footer\n     *  @type array\n     *  @default []\n     */\n    \"aoFooter\": [],\n\n    /**\n     * Store the applied global search information in case we want to force a\n     * research or compare the old search to a new one.\n     * Note that this parameter will be set by the initialisation routine. To\n     * set a default use {@link DataTable.defaults}.\n     *  @namespace\n     *  @extends DataTable.models.oSearch\n     */\n    \"oPreviousSearch\": {},\n\n    /**\n     * Store the applied search for each column - see\n     * {@link DataTable.models.oSearch} for the format that is used for the\n     * filtering information for each column.\n     *  @type array\n     *  @default []\n     */\n    \"aoPreSearchCols\": [],\n\n    /**\n     * Sorting that is applied to the table. Note that the inner arrays are\n     * used in the following manner:\n     * <ul>\n     *   <li>Index 0 - column number</li>\n     *   <li>Index 1 - current sorting direction</li>\n     * </ul>\n     * Note that this parameter will be set by the initialisation routine. To\n     * set a default use {@link DataTable.defaults}.\n     *  @type array\n     *  @todo These inner arrays should really be objects\n     */\n    \"aaSorting\": null,\n\n    /**\n     * Sorting that is always applied to the table (i.e. prefixed in front of\n     * aaSorting).\n     * Note that this parameter will be set by the initialisation routine. To\n     * set a default use {@link DataTable.defaults}.\n     *  @type array\n     *  @default []\n     */\n    \"aaSortingFixed\": [],\n\n    /**\n     * Classes to use for the striping of a table.\n     * Note that this parameter will be set by the initialisation routine. To\n     * set a default use {@link DataTable.defaults}.\n     *  @type array\n     *  @default []\n     */\n    \"asStripeClasses\": null,\n\n    /**\n     * If restoring a table - we should restore its striping classes as well\n     *  @type array\n     *  @default []\n     */\n    \"asDestroyStripes\": [],\n\n    /**\n     * If restoring a table - we should restore its width\n     *  @type int\n     *  @default 0\n     */\n    \"sDestroyWidth\": 0,\n\n    /**\n     * Callback functions array for every time a row is inserted (i.e. on a draw).\n     *  @type array\n     *  @default []\n     */\n    \"aoRowCallback\": [],\n\n    /**\n     * Callback functions for the header on each draw.\n     *  @type array\n     *  @default []\n     */\n    \"aoHeaderCallback\": [],\n\n    /**\n     * Callback function for the footer on each draw.\n     *  @type array\n     *  @default []\n     */\n    \"aoFooterCallback\": [],\n\n    /**\n     * Array of callback functions for draw callback functions\n     *  @type array\n     *  @default []\n     */\n    \"aoDrawCallback\": [],\n\n    /**\n     * Array of callback functions for row created function\n     *  @type array\n     *  @default []\n     */\n    \"aoRowCreatedCallback\": [],\n\n    /**\n     * Callback functions for just before the table is redrawn. A return of\n     * false will be used to cancel the draw.\n     *  @type array\n     *  @default []\n     */\n    \"aoPreDrawCallback\": [],\n\n    /**\n     * Callback functions for when the table has been initialised.\n     *  @type array\n     *  @default []\n     */\n    \"aoInitComplete\": [],\n\n    /**\n     * Callbacks for modifying the settings to be stored for state saving, prior to\n     * saving state.\n     *  @type array\n     *  @default []\n     */\n    \"aoStateSaveParams\": [],\n\n    /**\n     * Callbacks for modifying the settings that have been stored for state saving\n     * prior to using the stored values to restore the state.\n     *  @type array\n     *  @default []\n     */\n    \"aoStateLoadParams\": [],\n\n    /**\n     * Callbacks for operating on the settings object once the saved state has been\n     * loaded\n     *  @type array\n     *  @default []\n     */\n    \"aoStateLoaded\": [],\n\n    /**\n     * Cache the table ID for quick access\n     *  @type string\n     *  @default <i>Empty string</i>\n     */\n    \"sTableId\": \"\",\n\n    /**\n     * The TABLE node for the main table\n     *  @type node\n     *  @default null\n     */\n    \"nTable\": null,\n\n    /**\n     * Permanent ref to the thead element\n     *  @type node\n     *  @default null\n     */\n    \"nTHead\": null,\n\n    /**\n     * Permanent ref to the tfoot element - if it exists\n     *  @type node\n     *  @default null\n     */\n    \"nTFoot\": null,\n\n    /**\n     * Permanent ref to the tbody element\n     *  @type node\n     *  @default null\n     */\n    \"nTBody\": null,\n\n    /**\n     * Cache the wrapper node (contains all DataTables controlled elements)\n     *  @type node\n     *  @default null\n     */\n    \"nTableWrapper\": null,\n\n    /**\n     * Indicate if when using server-side processing the loading of data\n     * should be deferred until the second draw.\n     * Note that this parameter will be set by the initialisation routine. To\n     * set a default use {@link DataTable.defaults}.\n     *  @type boolean\n     *  @default false\n     */\n    \"bDeferLoading\": false,\n\n    /**\n     * Indicate if all required information has been read in\n     *  @type boolean\n     *  @default false\n     */\n    \"bInitialised\": false,\n\n    /**\n     * Information about open rows. Each object in the array has the parameters\n     * 'nTr' and 'nParent'\n     *  @type array\n     *  @default []\n     */\n    \"aoOpenRows\": [],\n\n    /**\n     * Dictate the positioning of DataTables' control elements - see\n     * {@link DataTable.model.oInit.sDom}.\n     * Note that this parameter will be set by the initialisation routine. To\n     * set a default use {@link DataTable.defaults}.\n     *  @type string\n     *  @default null\n     */\n    \"sDom\": null,\n\n    /**\n     * Search delay (in mS)\n     *  @type integer\n     *  @default null\n     */\n    \"searchDelay\": null,\n\n    /**\n     * Which type of pagination should be used.\n     * Note that this parameter will be set by the initialisation routine. To\n     * set a default use {@link DataTable.defaults}.\n     *  @type string\n     *  @default two_button\n     */\n    \"sPaginationType\": \"two_button\",\n\n    /**\n     * The state duration (for `stateSave`) in seconds.\n     * Note that this parameter will be set by the initialisation routine. To\n     * set a default use {@link DataTable.defaults}.\n     *  @type int\n     *  @default 0\n     */\n    \"iStateDuration\": 0,\n\n    /**\n     * Array of callback functions for state saving. Each array element is an\n     * object with the following parameters:\n     *   <ul>\n     *     <li>function:fn - function to call. Takes two parameters, oSettings\n     *       and the JSON string to save that has been thus far created. Returns\n     *       a JSON string to be inserted into a json object\n     *       (i.e. '\"param\": [ 0, 1, 2]')</li>\n     *     <li>string:sName - name of callback</li>\n     *   </ul>\n     *  @type array\n     *  @default []\n     */\n    \"aoStateSave\": [],\n\n    /**\n     * Array of callback functions for state loading. Each array element is an\n     * object with the following parameters:\n     *   <ul>\n     *     <li>function:fn - function to call. Takes two parameters, oSettings\n     *       and the object stored. May return false to cancel state loading</li>\n     *     <li>string:sName - name of callback</li>\n     *   </ul>\n     *  @type array\n     *  @default []\n     */\n    \"aoStateLoad\": [],\n\n    /**\n     * State that was saved. Useful for back reference\n     *  @type object\n     *  @default null\n     */\n    \"oSavedState\": null,\n\n    /**\n     * State that was loaded. Useful for back reference\n     *  @type object\n     *  @default null\n     */\n    \"oLoadedState\": null,\n\n    /**\n     * Source url for AJAX data for the table.\n     * Note that this parameter will be set by the initialisation routine. To\n     * set a default use {@link DataTable.defaults}.\n     *  @type string\n     *  @default null\n     */\n    \"sAjaxSource\": null,\n\n    /**\n     * Property from a given object from which to read the table data from. This\n     * can be an empty string (when not server-side processing), in which case\n     * it is  assumed an an array is given directly.\n     * Note that this parameter will be set by the initialisation routine. To\n     * set a default use {@link DataTable.defaults}.\n     *  @type string\n     */\n    \"sAjaxDataProp\": null,\n\n    /**\n     * Note if draw should be blocked while getting data\n     *  @type boolean\n     *  @default true\n     */\n    \"bAjaxDataGet\": true,\n\n    /**\n     * The last jQuery XHR object that was used for server-side data gathering.\n     * This can be used for working with the XHR information in one of the\n     * callbacks\n     *  @type object\n     *  @default null\n     */\n    \"jqXHR\": null,\n\n    /**\n     * JSON returned from the server in the last Ajax request\n     *  @type object\n     *  @default undefined\n     */\n    \"json\": undefined,\n\n    /**\n     * Data submitted as part of the last Ajax request\n     *  @type object\n     *  @default undefined\n     */\n    \"oAjaxData\": undefined,\n\n    /**\n     * Function to get the server-side data.\n     * Note that this parameter will be set by the initialisation routine. To\n     * set a default use {@link DataTable.defaults}.\n     *  @type function\n     */\n    \"fnServerData\": null,\n\n    /**\n     * Functions which are called prior to sending an Ajax request so extra\n     * parameters can easily be sent to the server\n     *  @type array\n     *  @default []\n     */\n    \"aoServerParams\": [],\n\n    /**\n     * Send the XHR HTTP method - GET or POST (could be PUT or DELETE if\n     * required).\n     * Note that this parameter will be set by the initialisation routine. To\n     * set a default use {@link DataTable.defaults}.\n     *  @type string\n     */\n    \"sServerMethod\": null,\n\n    /**\n     * Format numbers for display.\n     * Note that this parameter will be set by the initialisation routine. To\n     * set a default use {@link DataTable.defaults}.\n     *  @type function\n     */\n    \"fnFormatNumber\": null,\n\n    /**\n     * List of options that can be used for the user selectable length menu.\n     * Note that this parameter will be set by the initialisation routine. To\n     * set a default use {@link DataTable.defaults}.\n     *  @type array\n     *  @default []\n     */\n    \"aLengthMenu\": null,\n\n    /**\n     * Counter for the draws that the table does. Also used as a tracker for\n     * server-side processing\n     *  @type int\n     *  @default 0\n     */\n    \"iDraw\": 0,\n\n    /**\n     * Indicate if a redraw is being done - useful for Ajax\n     *  @type boolean\n     *  @default false\n     */\n    \"bDrawing\": false,\n\n    /**\n     * Draw index (iDraw) of the last error when parsing the returned data\n     *  @type int\n     *  @default -1\n     */\n    \"iDrawError\": -1,\n\n    /**\n     * Paging display length\n     *  @type int\n     *  @default 10\n     */\n    \"_iDisplayLength\": 10,\n\n    /**\n     * Paging start point - aiDisplay index\n     *  @type int\n     *  @default 0\n     */\n    \"_iDisplayStart\": 0,\n\n    /**\n     * Server-side processing - number of records in the result set\n     * (i.e. before filtering), Use fnRecordsTotal rather than\n     * this property to get the value of the number of records, regardless of\n     * the server-side processing setting.\n     *  @type int\n     *  @default 0\n     *  @private\n     */\n    \"_iRecordsTotal\": 0,\n\n    /**\n     * Server-side processing - number of records in the current display set\n     * (i.e. after filtering). Use fnRecordsDisplay rather than\n     * this property to get the value of the number of records, regardless of\n     * the server-side processing setting.\n     *  @type boolean\n     *  @default 0\n     *  @private\n     */\n    \"_iRecordsDisplay\": 0,\n\n    /**\n     * The classes to use for the table\n     *  @type object\n     *  @default {}\n     */\n    \"oClasses\": {},\n\n    /**\n     * Flag attached to the settings object so you can check in the draw\n     * callback if filtering has been done in the draw. Deprecated in favour of\n     * events.\n     *  @type boolean\n     *  @default false\n     *  @deprecated\n     */\n    \"bFiltered\": false,\n\n    /**\n     * Flag attached to the settings object so you can check in the draw\n     * callback if sorting has been done in the draw. Deprecated in favour of\n     * events.\n     *  @type boolean\n     *  @default false\n     *  @deprecated\n     */\n    \"bSorted\": false,\n\n    /**\n     * Indicate that if multiple rows are in the header and there is more than\n     * one unique cell per column, if the top one (true) or bottom one (false)\n     * should be used for sorting / title by DataTables.\n     * Note that this parameter will be set by the initialisation routine. To\n     * set a default use {@link DataTable.defaults}.\n     *  @type boolean\n     */\n    \"bSortCellsTop\": null,\n\n    /**\n     * Initialisation object that is used for the table\n     *  @type object\n     *  @default null\n     */\n    \"oInit\": null,\n\n    /**\n     * Destroy callback functions - for plug-ins to attach themselves to the\n     * destroy so they can clean up markup and events.\n     *  @type array\n     *  @default []\n     */\n    \"aoDestroyCallback\": [],\n\n    /**\n     * Get the number of records in the current record set, before filtering\n     *  @type function\n     */\n    \"fnRecordsTotal\": function fnRecordsTotal() {\n      return _fnDataSource(this) == 'ssp' ? this._iRecordsTotal * 1 : this.aiDisplayMaster.length;\n    },\n\n    /**\n     * Get the number of records in the current record set, after filtering\n     *  @type function\n     */\n    \"fnRecordsDisplay\": function fnRecordsDisplay() {\n      return _fnDataSource(this) == 'ssp' ? this._iRecordsDisplay * 1 : this.aiDisplay.length;\n    },\n\n    /**\n     * Get the display end point - aiDisplay index\n     *  @type function\n     */\n    \"fnDisplayEnd\": function fnDisplayEnd() {\n      var len = this._iDisplayLength,\n          start = this._iDisplayStart,\n          calc = start + len,\n          records = this.aiDisplay.length,\n          features = this.oFeatures,\n          paginate = features.bPaginate;\n\n      if (features.bServerSide) {\n        return paginate === false || len === -1 ? start + records : Math.min(start + len, this._iRecordsDisplay);\n      } else {\n        return !paginate || calc > records || len === -1 ? records : calc;\n      }\n    },\n\n    /**\n     * The DataTables object for this table\n     *  @type object\n     *  @default null\n     */\n    \"oInstance\": null,\n\n    /**\n     * Unique identifier for each instance of the DataTables object. If there\n     * is an ID on the table node, then it takes that value, otherwise an\n     * incrementing internal counter is used.\n     *  @type string\n     *  @default null\n     */\n    \"sInstance\": null,\n\n    /**\n     * tabindex attribute value that is added to DataTables control elements, allowing\n     * keyboard navigation of the table and its controls.\n     */\n    \"iTabIndex\": 0,\n\n    /**\n     * DIV container for the footer scrolling table if scrolling\n     */\n    \"nScrollHead\": null,\n\n    /**\n     * DIV container for the footer scrolling table if scrolling\n     */\n    \"nScrollFoot\": null,\n\n    /**\n     * Last applied sort\n     *  @type array\n     *  @default []\n     */\n    \"aLastSort\": [],\n\n    /**\n     * Stored plug-in instances\n     *  @type object\n     *  @default {}\n     */\n    \"oPlugins\": {},\n\n    /**\n     * Function used to get a row's id from the row's data\n     *  @type function\n     *  @default null\n     */\n    \"rowIdFn\": null,\n\n    /**\n     * Data location where to store a row's id\n     *  @type string\n     *  @default null\n     */\n    \"rowId\": null\n  };\n  /**\n   * Extension object for DataTables that is used to provide all extension\n   * options.\n   *\n   * Note that the `DataTable.ext` object is available through\n   * `jQuery.fn.dataTable.ext` where it may be accessed and manipulated. It is\n   * also aliased to `jQuery.fn.dataTableExt` for historic reasons.\n   *  @namespace\n   *  @extends DataTable.models.ext\n   */\n\n  /**\n   * 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   */\n\n  DataTable.ext = _ext = {\n    /**\n     * Buttons. For use with the Buttons extension for DataTables. This is\n     * defined here so other extensions can define buttons regardless of load\n     * order. It is _not_ used by DataTables core.\n     *\n     *  @type object\n     *  @default {}\n     */\n    buttons: {},\n\n    /**\n     * Element class names\n     *\n     *  @type object\n     *  @default {}\n     */\n    classes: {},\n\n    /**\n     * DataTables build type (expanded by the download builder)\n     *\n     *  @type string\n     */\n    builder: \"-source-\",\n\n    /**\n     * Error reporting.\n     * \n     * How should DataTables report an error. Can take the value 'alert',\n     * 'throw', 'none' or a function.\n     *\n     *  @type string|function\n     *  @default alert\n     */\n    errMode: \"alert\",\n\n    /**\n     * Feature plug-ins.\n     * \n     * This is an array of objects which describe the feature plug-ins that are\n     * available to DataTables. These feature plug-ins are then available for\n     * use through the `dom` initialisation option.\n     * \n     * Each feature plug-in is described by an object which must have the\n     * following properties:\n     * \n     * * `fnInit` - function that is used to initialise the plug-in,\n     * * `cFeature` - a character so the feature can be enabled by the `dom`\n     *   instillation option. This is case sensitive.\n     *\n     * The `fnInit` function has the following input parameters:\n     *\n     * 1. `{object}` DataTables settings object: see\n     *    {@link DataTable.models.oSettings}\n     *\n     * And the following return is expected:\n     * \n     * * {node|null} The element which contains your feature. Note that the\n     *   return may also be void if your plug-in does not require to inject any\n     *   DOM elements into DataTables control (`dom`) - for example this might\n     *   be useful when developing a plug-in which allows table control via\n     *   keyboard entry\n     *\n     *  @type array\n     *\n     *  @example\n     *    $.fn.dataTable.ext.features.push( {\n     *      \"fnInit\": function( oSettings ) {\n     *        return new TableTools( { \"oDTSettings\": oSettings } );\n     *      },\n     *      \"cFeature\": \"T\"\n     *    } );\n     */\n    feature: [],\n\n    /**\n     * Row searching.\n     * \n     * This method of searching is complimentary to the default type based\n     * searching, and a lot more comprehensive as it allows you complete control\n     * over the searching logic. Each element in this array is a function\n     * (parameters described below) that is called for every row in the table,\n     * and your logic decides if it should be included in the searching data set\n     * or not.\n     *\n     * Searching functions have the following input parameters:\n     *\n     * 1. `{object}` DataTables settings object: see\n     *    {@link DataTable.models.oSettings}\n     * 2. `{array|object}` Data for the row to be processed (same as the\n     *    original format that was passed in as the data source, or an array\n     *    from a DOM data source\n     * 3. `{int}` Row index ({@link DataTable.models.oSettings.aoData}), which\n     *    can be useful to retrieve the `TR` element if you need DOM interaction.\n     *\n     * And the following return is expected:\n     *\n     * * {boolean} Include the row in the searched result set (true) or not\n     *   (false)\n     *\n     * Note that as with the main search ability in DataTables, technically this\n     * is \"filtering\", since it is subtractive. However, for consistency in\n     * naming we call it searching here.\n     *\n     *  @type array\n     *  @default []\n     *\n     *  @example\n     *    // The following example shows custom search being applied to the\n     *    // fourth column (i.e. the data[3] index) based on two input values\n     *    // from the end-user, matching the data in a certain range.\n     *    $.fn.dataTable.ext.search.push(\n     *      function( settings, data, dataIndex ) {\n     *        var min = document.getElementById('min').value * 1;\n     *        var max = document.getElementById('max').value * 1;\n     *        var version = data[3] == \"-\" ? 0 : data[3]*1;\n     *\n     *        if ( min == \"\" && max == \"\" ) {\n     *          return true;\n     *        }\n     *        else if ( min == \"\" && version < max ) {\n     *          return true;\n     *        }\n     *        else if ( min < version && \"\" == max ) {\n     *          return true;\n     *        }\n     *        else if ( min < version && version < max ) {\n     *          return true;\n     *        }\n     *        return false;\n     *      }\n     *    );\n     */\n    search: [],\n\n    /**\n     * Selector extensions\n     *\n     * The `selector` option can be used to extend the options available for the\n     * selector modifier options (`selector-modifier` object data type) that\n     * each of the three built in selector types offer (row, column and cell +\n     * their plural counterparts). For example the Select extension uses this\n     * mechanism to provide an option to select only rows, columns and cells\n     * that have been marked as selected by the end user (`{selected: true}`),\n     * which can be used in conjunction with the existing built in selector\n     * options.\n     *\n     * Each property is an array to which functions can be pushed. The functions\n     * take three attributes:\n     *\n     * * Settings object for the host table\n     * * Options object (`selector-modifier` object type)\n     * * Array of selected item indexes\n     *\n     * The return is an array of the resulting item indexes after the custom\n     * selector has been applied.\n     *\n     *  @type object\n     */\n    selector: {\n      cell: [],\n      column: [],\n      row: []\n    },\n\n    /**\n     * Internal functions, exposed for used in plug-ins.\n     * \n     * Please note that you should not need to use the internal methods for\n     * anything other than a plug-in (and even then, try to avoid if possible).\n     * The internal function may change between releases.\n     *\n     *  @type object\n     *  @default {}\n     */\n    internal: {},\n\n    /**\n     * Legacy configuration options. Enable and disable legacy options that\n     * are available in DataTables.\n     *\n     *  @type object\n     */\n    legacy: {\n      /**\n       * Enable / disable DataTables 1.9 compatible server-side processing\n       * requests\n       *\n       *  @type boolean\n       *  @default null\n       */\n      ajax: null\n    },\n\n    /**\n     * Pagination plug-in methods.\n     * \n     * Each entry in this object is a function and defines which buttons should\n     * be shown by the pagination rendering method that is used for the table:\n     * {@link DataTable.ext.renderer.pageButton}. The renderer addresses how the\n     * buttons are displayed in the document, while the functions here tell it\n     * what buttons to display. This is done by returning an array of button\n     * descriptions (what each button will do).\n     *\n     * Pagination types (the four built in options and any additional plug-in\n     * options defined here) can be used through the `paginationType`\n     * initialisation parameter.\n     *\n     * The functions defined take two parameters:\n     *\n     * 1. `{int} page` The current page index\n     * 2. `{int} pages` The number of pages in the table\n     *\n     * Each function is expected to return an array where each element of the\n     * array can be one of:\n     *\n     * * `first` - Jump to first page when activated\n     * * `last` - Jump to last page when activated\n     * * `previous` - Show previous page when activated\n     * * `next` - Show next page when activated\n     * * `{int}` - Show page of the index given\n     * * `{array}` - A nested array containing the above elements to add a\n     *   containing 'DIV' element (might be useful for styling).\n     *\n     * Note that DataTables v1.9- used this object slightly differently whereby\n     * an object with two functions would be defined for each plug-in. That\n     * ability is still supported by DataTables 1.10+ to provide backwards\n     * compatibility, but this option of use is now decremented and no longer\n     * documented in DataTables 1.10+.\n     *\n     *  @type object\n     *  @default {}\n     *\n     *  @example\n     *    // Show previous, next and current page buttons only\n     *    $.fn.dataTableExt.oPagination.current = function ( page, pages ) {\n     *      return [ 'previous', page, 'next' ];\n     *    };\n     */\n    pager: {},\n    renderer: {\n      pageButton: {},\n      header: {}\n    },\n\n    /**\n     * Ordering plug-ins - custom data source\n     * \n     * The extension options for ordering of data available here is complimentary\n     * to the default type based ordering that DataTables typically uses. It\n     * allows much greater control over the the data that is being used to\n     * order a column, but is necessarily therefore more complex.\n     * \n     * This type of ordering is useful if you want to do ordering based on data\n     * live from the DOM (for example the contents of an 'input' element) rather\n     * than just the static string that DataTables knows of.\n     * \n     * The way these plug-ins work is that you create an array of the values you\n     * wish to be ordering for the column in question and then return that\n     * array. The data in the array much be in the index order of the rows in\n     * the table (not the currently ordering order!). Which order data gathering\n     * function is run here depends on the `dt-init columns.orderDataType`\n     * parameter that is used for the column (if any).\n     *\n     * The functions defined take two parameters:\n     *\n     * 1. `{object}` DataTables settings object: see\n     *    {@link DataTable.models.oSettings}\n     * 2. `{int}` Target column index\n     *\n     * Each function is expected to return an array:\n     *\n     * * `{array}` Data for the column to be ordering upon\n     *\n     *  @type array\n     *\n     *  @example\n     *    // Ordering using `input` node values\n     *    $.fn.dataTable.ext.order['dom-text'] = function  ( settings, col )\n     *    {\n     *      return this.api().column( col, {order:'index'} ).nodes().map( function ( td, i ) {\n     *        return $('input', td).val();\n     *      } );\n     *    }\n     */\n    order: {},\n\n    /**\n     * Type based plug-ins.\n     *\n     * Each column in DataTables has a type assigned to it, either by automatic\n     * detection or by direct assignment using the `type` option for the column.\n     * The type of a column will effect how it is ordering and search (plug-ins\n     * can also make use of the column type if required).\n     *\n     * @namespace\n     */\n    type: {\n      /**\n       * Type detection functions.\n       *\n       * The functions defined in this object are used to automatically detect\n       * a column's type, making initialisation of DataTables super easy, even\n       * when complex data is in the table.\n       *\n       * The functions defined take two parameters:\n       *\n          *  1. `{*}` Data from the column cell to be analysed\n          *  2. `{settings}` DataTables settings object. This can be used to\n          *     perform context specific type detection - for example detection\n          *     based on language settings such as using a comma for a decimal\n          *     place. Generally speaking the options from the settings will not\n          *     be required\n       *\n       * Each function is expected to return:\n       *\n       * * `{string|null}` Data type detected, or null if unknown (and thus\n       *   pass it on to the other type detection functions.\n       *\n       *  @type array\n       *\n       *  @example\n       *    // Currency type detection plug-in:\n       *    $.fn.dataTable.ext.type.detect.push(\n       *      function ( data, settings ) {\n       *        // Check the numeric part\n       *        if ( ! data.substring(1).match(/[0-9]/) ) {\n       *          return null;\n       *        }\n       *\n       *        // Check prefixed by currency\n       *        if ( data.charAt(0) == '$' || data.charAt(0) == '&pound;' ) {\n       *          return 'currency';\n       *        }\n       *        return null;\n       *      }\n       *    );\n       */\n      detect: [],\n\n      /**\n       * Type based search formatting.\n       *\n       * The type based searching functions can be used to pre-format the\n       * data to be search on. For example, it can be used to strip HTML\n       * tags or to de-format telephone numbers for numeric only searching.\n       *\n       * Note that is a search is not defined for a column of a given type,\n       * no search formatting will be performed.\n       * \n       * Pre-processing of searching data plug-ins - When you assign the sType\n       * for a column (or have it automatically detected for you by DataTables\n       * or a type detection plug-in), you will typically be using this for\n       * custom sorting, but it can also be used to provide custom searching\n       * by allowing you to pre-processing the data and returning the data in\n       * the format that should be searched upon. This is done by adding\n       * functions this object with a parameter name which matches the sType\n       * for that target column. This is the corollary of <i>afnSortData</i>\n       * for searching data.\n       *\n       * The functions defined take a single parameter:\n       *\n          *  1. `{*}` Data from the column cell to be prepared for searching\n       *\n       * Each function is expected to return:\n       *\n       * * `{string|null}` Formatted string that will be used for the searching.\n       *\n       *  @type object\n       *  @default {}\n       *\n       *  @example\n       *    $.fn.dataTable.ext.type.search['title-numeric'] = function ( d ) {\n       *      return d.replace(/\\n/g,\" \").replace( /<.*?>/g, \"\" );\n       *    }\n       */\n      search: {},\n\n      /**\n       * Type based ordering.\n       *\n       * The column type tells DataTables what ordering to apply to the table\n       * when a column is sorted upon. The order for each type that is defined,\n       * is defined by the functions available in this object.\n       *\n       * Each ordering option can be described by three properties added to\n       * this object:\n       *\n       * * `{type}-pre` - Pre-formatting function\n       * * `{type}-asc` - Ascending order function\n       * * `{type}-desc` - Descending order function\n       *\n       * All three can be used together, only `{type}-pre` or only\n       * `{type}-asc` and `{type}-desc` together. It is generally recommended\n       * that only `{type}-pre` is used, as this provides the optimal\n       * implementation in terms of speed, although the others are provided\n       * for compatibility with existing Javascript sort functions.\n       *\n       * `{type}-pre`: Functions defined take a single parameter:\n       *\n          *  1. `{*}` Data from the column cell to be prepared for ordering\n       *\n       * And return:\n       *\n       * * `{*}` Data to be sorted upon\n       *\n       * `{type}-asc` and `{type}-desc`: Functions are typical Javascript sort\n       * functions, taking two parameters:\n       *\n          *  1. `{*}` Data to compare to the second parameter\n          *  2. `{*}` Data to compare to the first parameter\n       *\n       * And returning:\n       *\n       * * `{*}` Ordering match: <0 if first parameter should be sorted lower\n       *   than the second parameter, ===0 if the two parameters are equal and\n       *   >0 if the first parameter should be sorted height than the second\n       *   parameter.\n       * \n       *  @type object\n       *  @default {}\n       *\n       *  @example\n       *    // Numeric ordering of formatted numbers with a pre-formatter\n       *    $.extend( $.fn.dataTable.ext.type.order, {\n       *      \"string-pre\": function(x) {\n       *        a = (a === \"-\" || a === \"\") ? 0 : a.replace( /[^\\d\\-\\.]/g, \"\" );\n       *        return parseFloat( a );\n       *      }\n       *    } );\n       *\n       *  @example\n       *    // Case-sensitive string ordering, with no pre-formatting method\n       *    $.extend( $.fn.dataTable.ext.order, {\n       *      \"string-case-asc\": function(x,y) {\n       *        return ((x < y) ? -1 : ((x > y) ? 1 : 0));\n       *      },\n       *      \"string-case-desc\": function(x,y) {\n       *        return ((x < y) ? 1 : ((x > y) ? -1 : 0));\n       *      }\n       *    } );\n       */\n      order: {}\n    },\n\n    /**\n     * Unique DataTables instance counter\n     *\n     * @type int\n     * @private\n     */\n    _unique: 0,\n    //\n    // Depreciated\n    // The following properties are retained for backwards compatiblity only.\n    // The should not be used in new projects and will be removed in a future\n    // version\n    //\n\n    /**\n     * Version check function.\n     *  @type function\n     *  @depreciated Since 1.10\n     */\n    fnVersionCheck: DataTable.fnVersionCheck,\n\n    /**\n     * Index for what 'this' index API functions should use\n     *  @type int\n     *  @deprecated Since v1.10\n     */\n    iApiIndex: 0,\n\n    /**\n     * jQuery UI class container\n     *  @type object\n     *  @deprecated Since v1.10\n     */\n    oJUIClasses: {},\n\n    /**\n     * Software version\n     *  @type string\n     *  @deprecated Since v1.10\n     */\n    sVersion: DataTable.version\n  }; //\n  // Backwards compatibility. Alias to pre 1.10 Hungarian notation counter parts\n  //\n\n  $.extend(_ext, {\n    afnFiltering: _ext.search,\n    aTypes: _ext.type.detect,\n    ofnSearch: _ext.type.search,\n    oSort: _ext.type.order,\n    afnSortData: _ext.order,\n    aoFeatures: _ext.feature,\n    oApi: _ext.internal,\n    oStdClasses: _ext.classes,\n    oPagination: _ext.pager\n  });\n  $.extend(DataTable.ext.classes, {\n    \"sTable\": \"dataTable\",\n    \"sNoFooter\": \"no-footer\",\n\n    /* Paging buttons */\n    \"sPageButton\": \"paginate_button\",\n    \"sPageButtonActive\": \"current\",\n    \"sPageButtonDisabled\": \"disabled\",\n\n    /* Striping classes */\n    \"sStripeOdd\": \"odd\",\n    \"sStripeEven\": \"even\",\n\n    /* Empty row */\n    \"sRowEmpty\": \"dataTables_empty\",\n\n    /* Features */\n    \"sWrapper\": \"dataTables_wrapper\",\n    \"sFilter\": \"dataTables_filter\",\n    \"sInfo\": \"dataTables_info\",\n    \"sPaging\": \"dataTables_paginate paging_\",\n\n    /* Note that the type is postfixed */\n    \"sLength\": \"dataTables_length\",\n    \"sProcessing\": \"dataTables_processing\",\n\n    /* Sorting */\n    \"sSortAsc\": \"sorting_asc\",\n    \"sSortDesc\": \"sorting_desc\",\n    \"sSortable\": \"sorting\",\n\n    /* Sortable in both directions */\n    \"sSortableAsc\": \"sorting_asc_disabled\",\n    \"sSortableDesc\": \"sorting_desc_disabled\",\n    \"sSortableNone\": \"sorting_disabled\",\n    \"sSortColumn\": \"sorting_\",\n\n    /* Note that an int is postfixed for the sorting order */\n\n    /* Filtering */\n    \"sFilterInput\": \"\",\n\n    /* Page length */\n    \"sLengthSelect\": \"\",\n\n    /* Scrolling */\n    \"sScrollWrapper\": \"dataTables_scroll\",\n    \"sScrollHead\": \"dataTables_scrollHead\",\n    \"sScrollHeadInner\": \"dataTables_scrollHeadInner\",\n    \"sScrollBody\": \"dataTables_scrollBody\",\n    \"sScrollFoot\": \"dataTables_scrollFoot\",\n    \"sScrollFootInner\": \"dataTables_scrollFootInner\",\n\n    /* Misc */\n    \"sHeaderTH\": \"\",\n    \"sFooterTH\": \"\",\n    // Deprecated\n    \"sSortJUIAsc\": \"\",\n    \"sSortJUIDesc\": \"\",\n    \"sSortJUI\": \"\",\n    \"sSortJUIAscAllowed\": \"\",\n    \"sSortJUIDescAllowed\": \"\",\n    \"sSortJUIWrapper\": \"\",\n    \"sSortIcon\": \"\",\n    \"sJUIHeader\": \"\",\n    \"sJUIFooter\": \"\"\n  });\n  var extPagination = DataTable.ext.pager;\n\n  function _numbers(page, pages) {\n    var numbers = [],\n        buttons = extPagination.numbers_length,\n        half = Math.floor(buttons / 2),\n        i = 1;\n\n    if (pages <= buttons) {\n      numbers = _range(0, pages);\n    } else if (page <= half) {\n      numbers = _range(0, buttons - 2);\n      numbers.push('ellipsis');\n      numbers.push(pages - 1);\n    } else if (page >= pages - 1 - half) {\n      numbers = _range(pages - (buttons - 2), pages);\n      numbers.splice(0, 0, 'ellipsis'); // no unshift in ie6\n\n      numbers.splice(0, 0, 0);\n    } else {\n      numbers = _range(page - half + 2, page + half - 1);\n      numbers.push('ellipsis');\n      numbers.push(pages - 1);\n      numbers.splice(0, 0, 'ellipsis');\n      numbers.splice(0, 0, 0);\n    }\n\n    numbers.DT_el = 'span';\n    return numbers;\n  }\n\n  $.extend(extPagination, {\n    simple: function simple(page, pages) {\n      return ['previous', 'next'];\n    },\n    full: function full(page, pages) {\n      return ['first', 'previous', 'next', 'last'];\n    },\n    numbers: function numbers(page, pages) {\n      return [_numbers(page, pages)];\n    },\n    simple_numbers: function simple_numbers(page, pages) {\n      return ['previous', _numbers(page, pages), 'next'];\n    },\n    full_numbers: function full_numbers(page, pages) {\n      return ['first', 'previous', _numbers(page, pages), 'next', 'last'];\n    },\n    first_last_numbers: function first_last_numbers(page, pages) {\n      return ['first', _numbers(page, pages), 'last'];\n    },\n    // For testing and plug-ins to use\n    _numbers: _numbers,\n    // Number of number buttons (including ellipsis) to show. _Must be odd!_\n    numbers_length: 7\n  });\n  $.extend(true, DataTable.ext.renderer, {\n    pageButton: {\n      _: function _(settings, host, idx, buttons, page, pages) {\n        var classes = settings.oClasses;\n        var lang = settings.oLanguage.oPaginate;\n        var aria = settings.oLanguage.oAria.paginate || {};\n        var btnDisplay,\n            btnClass,\n            counter = 0;\n\n        var attach = function attach(container, buttons) {\n          var i, ien, node, button;\n\n          var clickHandler = function clickHandler(e) {\n            _fnPageChange(settings, e.data.action, true);\n          };\n\n          for (i = 0, ien = buttons.length; i < ien; i++) {\n            button = buttons[i];\n\n            if ($.isArray(button)) {\n              var inner = $('<' + (button.DT_el || 'div') + '/>').appendTo(container);\n              attach(inner, button);\n            } else {\n              btnDisplay = null;\n              btnClass = '';\n\n              switch (button) {\n                case 'ellipsis':\n                  container.append('<span class=\"ellipsis\">&#x2026;</span>');\n                  break;\n\n                case 'first':\n                  btnDisplay = lang.sFirst;\n                  btnClass = button + (page > 0 ? '' : ' ' + classes.sPageButtonDisabled);\n                  break;\n\n                case 'previous':\n                  btnDisplay = lang.sPrevious;\n                  btnClass = button + (page > 0 ? '' : ' ' + classes.sPageButtonDisabled);\n                  break;\n\n                case 'next':\n                  btnDisplay = lang.sNext;\n                  btnClass = button + (page < pages - 1 ? '' : ' ' + classes.sPageButtonDisabled);\n                  break;\n\n                case 'last':\n                  btnDisplay = lang.sLast;\n                  btnClass = button + (page < pages - 1 ? '' : ' ' + classes.sPageButtonDisabled);\n                  break;\n\n                default:\n                  btnDisplay = button + 1;\n                  btnClass = page === button ? classes.sPageButtonActive : '';\n                  break;\n              }\n\n              if (btnDisplay !== null) {\n                node = $('<a>', {\n                  'class': classes.sPageButton + ' ' + btnClass,\n                  'aria-controls': settings.sTableId,\n                  'aria-label': aria[button],\n                  'data-dt-idx': counter,\n                  'tabindex': settings.iTabIndex,\n                  'id': idx === 0 && typeof button === 'string' ? settings.sTableId + '_' + button : null\n                }).html(btnDisplay).appendTo(container);\n\n                _fnBindAction(node, {\n                  action: button\n                }, clickHandler);\n\n                counter++;\n              }\n            }\n          }\n        }; // IE9 throws an 'unknown error' if document.activeElement is used\n        // inside an iframe or frame. Try / catch the error. Not good for\n        // accessibility, but neither are frames.\n\n\n        var activeEl;\n\n        try {\n          // Because this approach is destroying and recreating the paging\n          // elements, focus is lost on the select button which is bad for\n          // accessibility. So we want to restore focus once the draw has\n          // completed\n          activeEl = $(host).find(document.activeElement).data('dt-idx');\n        } catch (e) {}\n\n        attach($(host).empty(), buttons);\n\n        if (activeEl !== undefined) {\n          $(host).find('[data-dt-idx=' + activeEl + ']').focus();\n        }\n      }\n    }\n  }); // Built in type detection. See model.ext.aTypes for information about\n  // what is required from this methods.\n\n  $.extend(DataTable.ext.type.detect, [// Plain numbers - first since V8 detects some plain numbers as dates\n  // e.g. Date.parse('55') (but not all, e.g. Date.parse('22')...).\n  function (d, settings) {\n    var decimal = settings.oLanguage.sDecimal;\n    return _isNumber(d, decimal) ? 'num' + decimal : null;\n  }, // Dates (only those recognised by the browser's Date.parse)\n  function (d, settings) {\n    // V8 tries _very_ hard to make a string passed into `Date.parse()`\n    // valid, so we need to use a regex to restrict date formats. Use a\n    // plug-in for anything other than ISO8601 style strings\n    if (d && !(d instanceof Date) && !_re_date.test(d)) {\n      return null;\n    }\n\n    var parsed = Date.parse(d);\n    return parsed !== null && !isNaN(parsed) || _empty(d) ? 'date' : null;\n  }, // Formatted numbers\n  function (d, settings) {\n    var decimal = settings.oLanguage.sDecimal;\n    return _isNumber(d, decimal, true) ? 'num-fmt' + decimal : null;\n  }, // HTML numeric\n  function (d, settings) {\n    var decimal = settings.oLanguage.sDecimal;\n    return _htmlNumeric(d, decimal) ? 'html-num' + decimal : null;\n  }, // HTML numeric, formatted\n  function (d, settings) {\n    var decimal = settings.oLanguage.sDecimal;\n    return _htmlNumeric(d, decimal, true) ? 'html-num-fmt' + decimal : null;\n  }, // HTML (this is strict checking - there must be html)\n  function (d, settings) {\n    return _empty(d) || typeof d === 'string' && d.indexOf('<') !== -1 ? 'html' : null;\n  }]); // Filter formatting functions. See model.ext.ofnSearch for information about\n  // what is required from these methods.\n  // \n  // Note that additional search methods are added for the html numbers and\n  // html formatted numbers by `_addNumericSort()` when we know what the decimal\n  // place is\n\n  $.extend(DataTable.ext.type.search, {\n    html: function html(data) {\n      return _empty(data) ? data : typeof data === 'string' ? data.replace(_re_new_lines, \" \").replace(_re_html, \"\") : '';\n    },\n    string: function string(data) {\n      return _empty(data) ? data : typeof data === 'string' ? data.replace(_re_new_lines, \" \") : data;\n    }\n  });\n\n  var __numericReplace = function __numericReplace(d, decimalPlace, re1, re2) {\n    if (d !== 0 && (!d || d === '-')) {\n      return -Infinity;\n    } // If a decimal place other than `.` is used, it needs to be given to the\n    // function so we can detect it and replace with a `.` which is the only\n    // decimal place Javascript recognises - it is not locale aware.\n\n\n    if (decimalPlace) {\n      d = _numToDecimal(d, decimalPlace);\n    }\n\n    if (d.replace) {\n      if (re1) {\n        d = d.replace(re1, '');\n      }\n\n      if (re2) {\n        d = d.replace(re2, '');\n      }\n    }\n\n    return d * 1;\n  }; // Add the numeric 'deformatting' functions for sorting and search. This is done\n  // in a function to provide an easy ability for the language options to add\n  // additional methods if a non-period decimal place is used.\n\n\n  function _addNumericSort(decimalPlace) {\n    $.each({\n      // Plain numbers\n      \"num\": function num(d) {\n        return __numericReplace(d, decimalPlace);\n      },\n      // Formatted numbers\n      \"num-fmt\": function numFmt(d) {\n        return __numericReplace(d, decimalPlace, _re_formatted_numeric);\n      },\n      // HTML numeric\n      \"html-num\": function htmlNum(d) {\n        return __numericReplace(d, decimalPlace, _re_html);\n      },\n      // HTML numeric, formatted\n      \"html-num-fmt\": function htmlNumFmt(d) {\n        return __numericReplace(d, decimalPlace, _re_html, _re_formatted_numeric);\n      }\n    }, function (key, fn) {\n      // Add the ordering method\n      _ext.type.order[key + decimalPlace + '-pre'] = fn; // For HTML types add a search formatter that will strip the HTML\n\n      if (key.match(/^html\\-/)) {\n        _ext.type.search[key + decimalPlace] = _ext.type.search.html;\n      }\n    });\n  } // Default sort methods\n\n\n  $.extend(_ext.type.order, {\n    // Dates\n    \"date-pre\": function datePre(d) {\n      var ts = Date.parse(d);\n      return isNaN(ts) ? -Infinity : ts;\n    },\n    // html\n    \"html-pre\": function htmlPre(a) {\n      return _empty(a) ? '' : a.replace ? a.replace(/<.*?>/g, \"\").toLowerCase() : a + '';\n    },\n    // string\n    \"string-pre\": function stringPre(a) {\n      // This is a little complex, but faster than always calling toString,\n      // http://jsperf.com/tostring-v-check\n      return _empty(a) ? '' : typeof a === 'string' ? a.toLowerCase() : !a.toString ? '' : a.toString();\n    },\n    // string-asc and -desc are retained only for compatibility with the old\n    // sort methods\n    \"string-asc\": function stringAsc(x, y) {\n      return x < y ? -1 : x > y ? 1 : 0;\n    },\n    \"string-desc\": function stringDesc(x, y) {\n      return x < y ? 1 : x > y ? -1 : 0;\n    }\n  }); // Numeric sorting types - order doesn't matter here\n\n  _addNumericSort('');\n\n  $.extend(true, DataTable.ext.renderer, {\n    header: {\n      _: function _(settings, cell, column, classes) {\n        // No additional mark-up required\n        // Attach a sort listener to update on sort - note that using the\n        // `DT` namespace will allow the event to be removed automatically\n        // on destroy, while the `dt` namespaced event is the one we are\n        // listening for\n        $(settings.nTable).on('order.dt.DT', function (e, ctx, sorting, columns) {\n          if (settings !== ctx) {\n            // need to check this this is the host\n            return; // table, not a nested one\n          }\n\n          var colIdx = column.idx;\n          cell.removeClass(column.sSortingClass + ' ' + classes.sSortAsc + ' ' + classes.sSortDesc).addClass(columns[colIdx] == 'asc' ? classes.sSortAsc : columns[colIdx] == 'desc' ? classes.sSortDesc : column.sSortingClass);\n        });\n      },\n      jqueryui: function jqueryui(settings, cell, column, classes) {\n        $('<div/>').addClass(classes.sSortJUIWrapper).append(cell.contents()).append($('<span/>').addClass(classes.sSortIcon + ' ' + column.sSortingClassJUI)).appendTo(cell); // Attach a sort listener to update on sort\n\n        $(settings.nTable).on('order.dt.DT', function (e, ctx, sorting, columns) {\n          if (settings !== ctx) {\n            return;\n          }\n\n          var colIdx = column.idx;\n          cell.removeClass(classes.sSortAsc + \" \" + classes.sSortDesc).addClass(columns[colIdx] == 'asc' ? classes.sSortAsc : columns[colIdx] == 'desc' ? classes.sSortDesc : column.sSortingClass);\n          cell.find('span.' + classes.sSortIcon).removeClass(classes.sSortJUIAsc + \" \" + classes.sSortJUIDesc + \" \" + classes.sSortJUI + \" \" + classes.sSortJUIAscAllowed + \" \" + classes.sSortJUIDescAllowed).addClass(columns[colIdx] == 'asc' ? classes.sSortJUIAsc : columns[colIdx] == 'desc' ? classes.sSortJUIDesc : column.sSortingClassJUI);\n        });\n      }\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  var __htmlEscapeEntities = function __htmlEscapeEntities(d) {\n    return typeof d === 'string' ? d.replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/\"/g, '&quot;') : d;\n  };\n  /**\n   * Helpers for `columns.render`.\n   *\n   * The options defined here can be used with the `columns.render` initialisation\n   * option to provide a display renderer. The following functions are defined:\n   *\n   * * `number` - Will format numeric data (defined by `columns.data`) for\n   *   display, retaining the original unformatted data for sorting and filtering.\n   *   It takes 5 parameters:\n   *   * `string` - Thousands grouping separator\n   *   * `string` - Decimal point indicator\n   *   * `integer` - Number of decimal points to show\n   *   * `string` (optional) - Prefix.\n   *   * `string` (optional) - Postfix (/suffix).\n   * * `text` - Escape HTML to help prevent XSS attacks. It has no optional\n   *   parameters.\n   *\n   * @example\n   *   // Column definition using the number renderer\n   *   {\n   *     data: \"salary\",\n   *     render: $.fn.dataTable.render.number( '\\'', '.', 0, '$' )\n   *   }\n   *\n   * @namespace\n   */\n\n\n  DataTable.render = {\n    number: function number(thousands, decimal, precision, prefix, postfix) {\n      return {\n        display: function display(d) {\n          if (typeof d !== 'number' && typeof d !== 'string') {\n            return d;\n          }\n\n          var negative = d < 0 ? '-' : '';\n          var flo = parseFloat(d); // If NaN then there isn't much formatting that we can do - just\n          // return immediately, escaping any HTML (this was supposed to\n          // be a number after all)\n\n          if (isNaN(flo)) {\n            return __htmlEscapeEntities(d);\n          }\n\n          flo = flo.toFixed(precision);\n          d = Math.abs(flo);\n          var intPart = parseInt(d, 10);\n          var floatPart = precision ? decimal + (d - intPart).toFixed(precision).substring(2) : '';\n          return negative + (prefix || '') + intPart.toString().replace(/\\B(?=(\\d{3})+(?!\\d))/g, thousands) + floatPart + (postfix || '');\n        }\n      };\n    },\n    text: function text() {\n      return {\n        display: __htmlEscapeEntities,\n        filter: __htmlEscapeEntities\n      };\n    }\n  };\n  /*\n   * This is really a good bit rubbish this method of exposing the internal methods\n   * publicly... - To be fixed in 2.0 using methods on the prototype\n   */\n\n  /**\n   * Create a wrapper function for exporting an internal functions to an external API.\n   *  @param {string} fn API function name\n   *  @returns {function} wrapped function\n   *  @memberof DataTable#internal\n   */\n\n  function _fnExternApiFunc(fn) {\n    return function () {\n      var args = [_fnSettingsFromNode(this[DataTable.ext.iApiIndex])].concat(Array.prototype.slice.call(arguments));\n      return DataTable.ext.internal[fn].apply(this, args);\n    };\n  }\n  /**\n   * Reference to internal functions for use by plug-in developers. Note that\n   * these methods are references to internal functions and are considered to be\n   * private. If you use these methods, be aware that they are liable to change\n   * between versions.\n   *  @namespace\n   */\n\n\n  $.extend(DataTable.ext.internal, {\n    _fnExternApiFunc: _fnExternApiFunc,\n    _fnBuildAjax: _fnBuildAjax,\n    _fnAjaxUpdate: _fnAjaxUpdate,\n    _fnAjaxParameters: _fnAjaxParameters,\n    _fnAjaxUpdateDraw: _fnAjaxUpdateDraw,\n    _fnAjaxDataSrc: _fnAjaxDataSrc,\n    _fnAddColumn: _fnAddColumn,\n    _fnColumnOptions: _fnColumnOptions,\n    _fnAdjustColumnSizing: _fnAdjustColumnSizing,\n    _fnVisibleToColumnIndex: _fnVisibleToColumnIndex,\n    _fnColumnIndexToVisible: _fnColumnIndexToVisible,\n    _fnVisbleColumns: _fnVisbleColumns,\n    _fnGetColumns: _fnGetColumns,\n    _fnColumnTypes: _fnColumnTypes,\n    _fnApplyColumnDefs: _fnApplyColumnDefs,\n    _fnHungarianMap: _fnHungarianMap,\n    _fnCamelToHungarian: _fnCamelToHungarian,\n    _fnLanguageCompat: _fnLanguageCompat,\n    _fnBrowserDetect: _fnBrowserDetect,\n    _fnAddData: _fnAddData,\n    _fnAddTr: _fnAddTr,\n    _fnNodeToDataIndex: _fnNodeToDataIndex,\n    _fnNodeToColumnIndex: _fnNodeToColumnIndex,\n    _fnGetCellData: _fnGetCellData,\n    _fnSetCellData: _fnSetCellData,\n    _fnSplitObjNotation: _fnSplitObjNotation,\n    _fnGetObjectDataFn: _fnGetObjectDataFn,\n    _fnSetObjectDataFn: _fnSetObjectDataFn,\n    _fnGetDataMaster: _fnGetDataMaster,\n    _fnClearTable: _fnClearTable,\n    _fnDeleteIndex: _fnDeleteIndex,\n    _fnInvalidate: _fnInvalidate,\n    _fnGetRowElements: _fnGetRowElements,\n    _fnCreateTr: _fnCreateTr,\n    _fnBuildHead: _fnBuildHead,\n    _fnDrawHead: _fnDrawHead,\n    _fnDraw: _fnDraw,\n    _fnReDraw: _fnReDraw,\n    _fnAddOptionsHtml: _fnAddOptionsHtml,\n    _fnDetectHeader: _fnDetectHeader,\n    _fnGetUniqueThs: _fnGetUniqueThs,\n    _fnFeatureHtmlFilter: _fnFeatureHtmlFilter,\n    _fnFilterComplete: _fnFilterComplete,\n    _fnFilterCustom: _fnFilterCustom,\n    _fnFilterColumn: _fnFilterColumn,\n    _fnFilter: _fnFilter,\n    _fnFilterCreateSearch: _fnFilterCreateSearch,\n    _fnEscapeRegex: _fnEscapeRegex,\n    _fnFilterData: _fnFilterData,\n    _fnFeatureHtmlInfo: _fnFeatureHtmlInfo,\n    _fnUpdateInfo: _fnUpdateInfo,\n    _fnInfoMacros: _fnInfoMacros,\n    _fnInitialise: _fnInitialise,\n    _fnInitComplete: _fnInitComplete,\n    _fnLengthChange: _fnLengthChange,\n    _fnFeatureHtmlLength: _fnFeatureHtmlLength,\n    _fnFeatureHtmlPaginate: _fnFeatureHtmlPaginate,\n    _fnPageChange: _fnPageChange,\n    _fnFeatureHtmlProcessing: _fnFeatureHtmlProcessing,\n    _fnProcessingDisplay: _fnProcessingDisplay,\n    _fnFeatureHtmlTable: _fnFeatureHtmlTable,\n    _fnScrollDraw: _fnScrollDraw,\n    _fnApplyToChildren: _fnApplyToChildren,\n    _fnCalculateColumnWidths: _fnCalculateColumnWidths,\n    _fnThrottle: _fnThrottle,\n    _fnConvertToWidth: _fnConvertToWidth,\n    _fnGetWidestNode: _fnGetWidestNode,\n    _fnGetMaxLenString: _fnGetMaxLenString,\n    _fnStringToCss: _fnStringToCss,\n    _fnSortFlatten: _fnSortFlatten,\n    _fnSort: _fnSort,\n    _fnSortAria: _fnSortAria,\n    _fnSortListener: _fnSortListener,\n    _fnSortAttachListener: _fnSortAttachListener,\n    _fnSortingClasses: _fnSortingClasses,\n    _fnSortData: _fnSortData,\n    _fnSaveState: _fnSaveState,\n    _fnLoadState: _fnLoadState,\n    _fnSettingsFromNode: _fnSettingsFromNode,\n    _fnLog: _fnLog,\n    _fnMap: _fnMap,\n    _fnBindAction: _fnBindAction,\n    _fnCallbackReg: _fnCallbackReg,\n    _fnCallbackFire: _fnCallbackFire,\n    _fnLengthOverflow: _fnLengthOverflow,\n    _fnRenderer: _fnRenderer,\n    _fnDataSource: _fnDataSource,\n    _fnRowAttributes: _fnRowAttributes,\n    _fnExtend: _fnExtend,\n    _fnCalculateEnd: function _fnCalculateEnd() {} // Used by a lot of plug-ins, but redundant\n    // in 1.10, so this dead-end function is\n    // added to prevent errors\n\n  }); // jQuery access\n\n  $.fn.dataTable = DataTable; // Provide access to the host jQuery object (circular reference)\n\n  DataTable.$ = $; // Legacy aliases\n\n  $.fn.dataTableSettings = DataTable.settings;\n  $.fn.dataTableExt = DataTable.ext; // With a capital `D` we return a DataTables API instance rather than a\n  // jQuery object\n\n  $.fn.DataTable = function (opts) {\n    return $(this).dataTable(opts).api();\n  }; // All properties that are available to $.fn.dataTable should also be\n  // available on $.fn.DataTable\n\n\n  $.each(DataTable, function (prop, val) {\n    $.fn.DataTable[prop] = val;\n  }); // Information about events fired by DataTables - for documentation.\n\n  /**\n   * Draw event, fired whenever the table is redrawn on the page, at the same\n   * point as fnDrawCallback. This may be useful for binding events or\n   * performing calculations when the table is altered at all.\n   *  @name DataTable#draw.dt\n   *  @event\n   *  @param {event} e jQuery event object\n   *  @param {object} o DataTables settings object {@link DataTable.models.oSettings}\n   */\n\n  /**\n   * Search event, fired when the searching applied to the table (using the\n   * built-in global search, or column filters) is altered.\n   *  @name DataTable#search.dt\n   *  @event\n   *  @param {event} e jQuery event object\n   *  @param {object} o DataTables settings object {@link DataTable.models.oSettings}\n   */\n\n  /**\n   * Page change event, fired when the paging of the table is altered.\n   *  @name DataTable#page.dt\n   *  @event\n   *  @param {event} e jQuery event object\n   *  @param {object} o DataTables settings object {@link DataTable.models.oSettings}\n   */\n\n  /**\n   * Order event, fired when the ordering applied to the table is altered.\n   *  @name DataTable#order.dt\n   *  @event\n   *  @param {event} e jQuery event object\n   *  @param {object} o DataTables settings object {@link DataTable.models.oSettings}\n   */\n\n  /**\n   * DataTables initialisation complete event, fired when the table is fully\n   * drawn, including Ajax data loaded, if Ajax data is required.\n   *  @name DataTable#init.dt\n   *  @event\n   *  @param {event} e jQuery event object\n   *  @param {object} oSettings DataTables settings object\n   *  @param {object} json The JSON object request from the server - only\n   *    present if client-side Ajax sourced data is used</li></ol>\n   */\n\n  /**\n   * State save event, fired when the table has changed state a new state save\n   * is required. This event allows modification of the state saving object\n   * prior to actually doing the save, including addition or other state\n   * properties (for plug-ins) or modification of a DataTables core property.\n   *  @name DataTable#stateSaveParams.dt\n   *  @event\n   *  @param {event} e jQuery event object\n   *  @param {object} oSettings DataTables settings object\n   *  @param {object} json The state information to be saved\n   */\n\n  /**\n   * State load event, fired when the table is loading state from the stored\n   * data, but prior to the settings object being modified by the saved state\n   * - allowing modification of the saved state is required or loading of\n   * state for a plug-in.\n   *  @name DataTable#stateLoadParams.dt\n   *  @event\n   *  @param {event} e jQuery event object\n   *  @param {object} oSettings DataTables settings object\n   *  @param {object} json The saved state information\n   */\n\n  /**\n   * State loaded event, fired when state has been loaded from stored data and\n   * the settings object has been modified by the loaded data.\n   *  @name DataTable#stateLoaded.dt\n   *  @event\n   *  @param {event} e jQuery event object\n   *  @param {object} oSettings DataTables settings object\n   *  @param {object} json The saved state information\n   */\n\n  /**\n   * Processing event, fired when DataTables is doing some kind of processing\n   * (be it, order, searcg or anything else). It can be used to indicate to\n   * the end user that there is something happening, or that something has\n   * finished.\n   *  @name DataTable#processing.dt\n   *  @event\n   *  @param {event} e jQuery event object\n   *  @param {object} oSettings DataTables settings object\n   *  @param {boolean} bShow Flag for if DataTables is doing processing or not\n   */\n\n  /**\n   * Ajax (XHR) event, fired whenever an Ajax request is completed from a\n   * request to made to the server for new data. This event is called before\n   * DataTables processed the returned data, so it can also be used to pre-\n   * process the data returned from the server, if needed.\n   *\n   * Note that this trigger is called in `fnServerData`, if you override\n   * `fnServerData` and which to use this event, you need to trigger it in you\n   * success function.\n   *  @name DataTable#xhr.dt\n   *  @event\n   *  @param {event} e jQuery event object\n   *  @param {object} o DataTables settings object {@link DataTable.models.oSettings}\n   *  @param {object} json JSON returned from the server\n   *\n   *  @example\n   *     // Use a custom property returned from the server in another DOM element\n   *     $('#table').dataTable().on('xhr.dt', function (e, settings, json) {\n   *       $('#status').html( json.status );\n   *     } );\n   *\n   *  @example\n   *     // Pre-process the data returned from the server\n   *     $('#table').dataTable().on('xhr.dt', function (e, settings, json) {\n   *       for ( var i=0, ien=json.aaData.length ; i<ien ; i++ ) {\n   *         json.aaData[i].sum = json.aaData[i].one + json.aaData[i].two;\n   *       }\n   *       // Note no return - manipulate the data directly in the JSON object.\n   *     } );\n   */\n\n  /**\n   * Destroy event, fired when the DataTable is destroyed by calling fnDestroy\n   * or passing the bDestroy:true parameter in the initialisation object. This\n   * can be used to remove bound events, added DOM nodes, etc.\n   *  @name DataTable#destroy.dt\n   *  @event\n   *  @param {event} e jQuery event object\n   *  @param {object} o DataTables settings object {@link DataTable.models.oSettings}\n   */\n\n  /**\n   * Page length change event, fired when number of records to show on each\n   * page (the length) is changed.\n   *  @name DataTable#length.dt\n   *  @event\n   *  @param {event} e jQuery event object\n   *  @param {object} o DataTables settings object {@link DataTable.models.oSettings}\n   *  @param {integer} len New length\n   */\n\n  /**\n   * Column sizing has changed.\n   *  @name DataTable#column-sizing.dt\n   *  @event\n   *  @param {event} e jQuery event object\n   *  @param {object} o DataTables settings object {@link DataTable.models.oSettings}\n   */\n\n  /**\n   * Column visibility has changed.\n   *  @name DataTable#column-visibility.dt\n   *  @event\n   *  @param {event} e jQuery event object\n   *  @param {object} o DataTables settings object {@link DataTable.models.oSettings}\n   *  @param {int} column Column index\n   *  @param {bool} vis `false` if column now hidden, or `true` if visible\n   */\n\n  return $.fn.dataTable;\n});"],"sourceRoot":""}