{"version":3,"sources":["../node_modules/datatables.net-responsive/js/dataTables.responsive.js","../node_modules/datatables.net-responsive-bs/js/responsive.bootstrap.js"],"names":["__WEBPACK_AMD_DEFINE_ARRAY__","__WEBPACK_AMD_DEFINE_RESULT__","__webpack_require__","undefined","$","window","document","DataTable","fn","dataTable","Responsive","settings","opts","versionCheck","this","s","dt","Api","columns","current","responsive","details","type","c","extend","defaults","_constructor","prototype","that","dtPrivateSettings","oldWindowWidth","width","_responsive","on","util","throttle","_resize","oApi","_fnCallbackReg","tr","data","idx","inArray","each","i","column","index","css","off","table","body","val","_setColumnVis","breakpoints","sort","a","b","_classLogic","_resizeAuto","_detailsInit","_timer","clearTimeout","setTimeout","_redrawChildren","node","addClass","e","rowIds","rows","every","child","isShown","push","id","one","_detailsDisplay","adjust","_columnsVisiblity","breakpoint","ien","order","map","col","columnIdx","priority","display","visible","auto","minWidth","includeIn","requiredWidth","length","scrolling","oScroll","bar","sY","sX","iBarWidth","widthAvailable","container","offsetWidth","usedWidth","control","empty","colIdx","showControl","never","eq","className","header","aoColumns","responsivePriority","dataPriority","match","add","name","operator","matched","size","_find","indexOf","classNames","split","hasClass","k","ken","trim","j","brokenPoint","re","RegExp","row","update","res","renderer","_detailsObj","triggerHandler","target","_tabIndexes","keyCode","click","selector","closest","get","nodes","toArray","targetIdx","cell","blur","rowIdx","title","sTitle","render","orthogonal","hidden","columnIndex","rowIndex","page","iterator","oldVis","slice","columnsVis","collapsedClass","toggleClass","changed","trigger","info","recordsDisplay","attr","isEmptyObject","_childNodeStore","key","_childNodesRestore","clonedTable","cloneNode","clonedHeader","appendTo","clonedBody","clone","headerCells","filter","to$","append","find","footer","clonedFooter","footerCells","removeAttr","inserted","height","overflow","clear","insertBefore","remove","showHide","cells","indexes","ctx","removeData","iTabIndex","Infinity","childRow","show","removeClass","childRowImmediate","hasHidden","modal","options","close","stopPropagation","prepend","store","parent","parentNode","parentChildren","childNodes","jen","appendChild","listHiddenNodes","api","ul","found","children","_childNodes","listHidden","join","tableAll","tableClass","register","li","context","registerPlural","version","json","namespace","nTable","oInit","init","isPlainObject","factory","apply","exports","module","_display","_original","_modal","button","detach"],"mappings":"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","file":"static/js/16.9b41e1f0.chunk.js","sourcesContent":["/*! Responsive 2.2.3\n * 2014-2018 SpryMedia Ltd - datatables.net/license\n */\n\n/**\n * @summary     Responsive\n * @description Responsive tables plug-in for DataTables\n * @version     2.2.3\n * @file        dataTables.responsive.js\n * @author      SpryMedia Ltd (www.sprymedia.co.uk)\n * @contact     www.sprymedia.co.uk/contact\n * @copyright   Copyright 2014-2018 SpryMedia Ltd.\n *\n * This source file is free software, available under the following license:\n *   MIT license - http://datatables.net/license/mit\n *\n * This source file is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\n * or FITNESS FOR A PARTICULAR PURPOSE. See the license files for details.\n *\n * For details please refer to: http://www.datatables.net\n */\n(function (factory) {\n  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.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  /**\n   * Responsive is a plug-in for the DataTables library that makes use of\n   * DataTables' ability to change the visibility of columns, changing the\n   * visibility of columns so the displayed columns fit into the table container.\n   * The end result is that complex tables will be dynamically adjusted to fit\n   * into the viewport, be it on a desktop, tablet or mobile browser.\n   *\n   * Responsive for DataTables has two modes of operation, which can used\n   * individually or combined:\n   *\n   * * Class name based control - columns assigned class names that match the\n   *   breakpoint logic can be shown / hidden as required for each breakpoint.\n   * * Automatic control - columns are automatically hidden when there is no\n   *   room left to display them. Columns removed from the right.\n   *\n   * In additional to column visibility control, Responsive also has built into\n   * options to use DataTables' child row display to show / hide the information\n   * from the table that has been hidden. There are also two modes of operation\n   * for this child row display:\n   *\n   * * Inline - when the control element that the user can use to show / hide\n   *   child rows is displayed inside the first column of the table.\n   * * Column - where a whole column is dedicated to be the show / hide control.\n   *\n   * Initialisation of Responsive is performed by:\n   *\n   * * Adding the class `responsive` or `dt-responsive` to the table. In this case\n   *   Responsive will automatically be initialised with the default configuration\n   *   options when the DataTable is created.\n   * * Using the `responsive` option in the DataTables configuration options. This\n   *   can also be used to specify the configuration options, or simply set to\n   *   `true` to use the defaults.\n   *\n   *  @class\n   *  @param {object} settings DataTables settings object for the host table\n   *  @param {object} [opts] Configuration options\n   *  @requires jQuery 1.7+\n   *  @requires DataTables 1.10.3+\n   *\n   *  @example\n   *      $('#example').DataTable( {\n   *        responsive: true\n   *      } );\n   *    } );\n   */\n\n  var Responsive = function Responsive(settings, opts) {\n    // Sanity check that we are using DataTables 1.10 or newer\n    if (!DataTable.versionCheck || !DataTable.versionCheck('1.10.10')) {\n      throw 'DataTables Responsive requires DataTables 1.10.10 or newer';\n    }\n\n    this.s = {\n      dt: new DataTable.Api(settings),\n      columns: [],\n      current: []\n    }; // Check if responsive has already been initialised on this table\n\n    if (this.s.dt.settings()[0].responsive) {\n      return;\n    } // details is an object, but for simplicity the user can give it as a string\n    // or a boolean\n\n\n    if (opts && typeof opts.details === 'string') {\n      opts.details = {\n        type: opts.details\n      };\n    } else if (opts && opts.details === false) {\n      opts.details = {\n        type: false\n      };\n    } else if (opts && opts.details === true) {\n      opts.details = {\n        type: 'inline'\n      };\n    }\n\n    this.c = $.extend(true, {}, Responsive.defaults, DataTable.defaults.responsive, opts);\n    settings.responsive = this;\n\n    this._constructor();\n  };\n\n  $.extend(Responsive.prototype, {\n    /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n     * Constructor\n     */\n\n    /**\n     * Initialise the Responsive instance\n     *\n     * @private\n     */\n    _constructor: function _constructor() {\n      var that = this;\n      var dt = this.s.dt;\n      var dtPrivateSettings = dt.settings()[0];\n      var oldWindowWidth = $(window).width();\n      dt.settings()[0]._responsive = this; // Use DataTables' throttle function to avoid processor thrashing on\n      // resize\n\n      $(window).on('resize.dtr orientationchange.dtr', DataTable.util.throttle(function () {\n        // iOS has a bug whereby resize can fire when only scrolling\n        // See: http://stackoverflow.com/questions/8898412\n        var width = $(window).width();\n\n        if (width !== oldWindowWidth) {\n          that._resize();\n\n          oldWindowWidth = width;\n        }\n      })); // DataTables doesn't currently trigger an event when a row is added, so\n      // we need to hook into its private API to enforce the hidden rows when\n      // new data is added\n\n      dtPrivateSettings.oApi._fnCallbackReg(dtPrivateSettings, 'aoRowCreatedCallback', function (tr, data, idx) {\n        if ($.inArray(false, that.s.current) !== -1) {\n          $('>td, >th', tr).each(function (i) {\n            var idx = dt.column.index('toData', i);\n\n            if (that.s.current[idx] === false) {\n              $(this).css('display', 'none');\n            }\n          });\n        }\n      }); // Destroy event handler\n\n\n      dt.on('destroy.dtr', function () {\n        dt.off('.dtr');\n        $(dt.table().body()).off('.dtr');\n        $(window).off('resize.dtr orientationchange.dtr'); // Restore the columns that we've hidden\n\n        $.each(that.s.current, function (i, val) {\n          if (val === false) {\n            that._setColumnVis(i, true);\n          }\n        });\n      }); // Reorder the breakpoints array here in case they have been added out\n      // of order\n\n      this.c.breakpoints.sort(function (a, b) {\n        return a.width < b.width ? 1 : a.width > b.width ? -1 : 0;\n      });\n\n      this._classLogic();\n\n      this._resizeAuto(); // Details handler\n\n\n      var details = this.c.details;\n\n      if (details.type !== false) {\n        that._detailsInit(); // DataTables will trigger this event on every column it shows and\n        // hides individually\n\n\n        dt.on('column-visibility.dtr', function () {\n          // Use a small debounce to allow multiple columns to be set together\n          if (that._timer) {\n            clearTimeout(that._timer);\n          }\n\n          that._timer = setTimeout(function () {\n            that._timer = null;\n\n            that._classLogic();\n\n            that._resizeAuto();\n\n            that._resize();\n\n            that._redrawChildren();\n          }, 100);\n        }); // Redraw the details box on each draw which will happen if the data\n        // has changed. This is used until DataTables implements a native\n        // `updated` event for rows\n\n        dt.on('draw.dtr', function () {\n          that._redrawChildren();\n        });\n        $(dt.table().node()).addClass('dtr-' + details.type);\n      }\n\n      dt.on('column-reorder.dtr', function (e, settings, details) {\n        that._classLogic();\n\n        that._resizeAuto();\n\n        that._resize();\n      }); // Change in column sizes means we need to calc\n\n      dt.on('column-sizing.dtr', function () {\n        that._resizeAuto();\n\n        that._resize();\n      }); // On Ajax reload we want to reopen any child rows which are displayed\n      // by responsive\n\n      dt.on('preXhr.dtr', function () {\n        var rowIds = [];\n        dt.rows().every(function () {\n          if (this.child.isShown()) {\n            rowIds.push(this.id(true));\n          }\n        });\n        dt.one('draw.dtr', function () {\n          that._resizeAuto();\n\n          that._resize();\n\n          dt.rows(rowIds).every(function () {\n            that._detailsDisplay(this, false);\n          });\n        });\n      });\n      dt.on('init.dtr', function (e, settings, details) {\n        that._resizeAuto();\n\n        that._resize(); // If columns were hidden, then DataTables needs to adjust the\n        // column sizing\n\n\n        if ($.inArray(false, that.s.current)) {\n          dt.columns.adjust();\n        }\n      }); // First pass - draw the table for the current viewport size\n\n      this._resize();\n    },\n\n    /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n     * Private methods\n     */\n\n    /**\n     * Calculate the visibility for the columns in a table for a given\n     * breakpoint. The result is pre-determined based on the class logic if\n     * class names are used to control all columns, but the width of the table\n     * is also used if there are columns which are to be automatically shown\n     * and hidden.\n     *\n     * @param  {string} breakpoint Breakpoint name to use for the calculation\n     * @return {array} Array of boolean values initiating the visibility of each\n     *   column.\n     *  @private\n     */\n    _columnsVisiblity: function _columnsVisiblity(breakpoint) {\n      var dt = this.s.dt;\n      var columns = this.s.columns;\n      var i, ien; // Create an array that defines the column ordering based first on the\n      // column's priority, and secondly the column index. This allows the\n      // columns to be removed from the right if the priority matches\n\n      var order = columns.map(function (col, idx) {\n        return {\n          columnIdx: idx,\n          priority: col.priority\n        };\n      }).sort(function (a, b) {\n        if (a.priority !== b.priority) {\n          return a.priority - b.priority;\n        }\n\n        return a.columnIdx - b.columnIdx;\n      }); // Class logic - determine which columns are in this breakpoint based\n      // on the classes. If no class control (i.e. `auto`) then `-` is used\n      // to indicate this to the rest of the function\n\n      var display = $.map(columns, function (col, i) {\n        if (dt.column(i).visible() === false) {\n          return 'not-visible';\n        }\n\n        return col.auto && col.minWidth === null ? false : col.auto === true ? '-' : $.inArray(breakpoint, col.includeIn) !== -1;\n      }); // Auto column control - first pass: how much width is taken by the\n      // ones that must be included from the non-auto columns\n\n      var requiredWidth = 0;\n\n      for (i = 0, ien = display.length; i < ien; i++) {\n        if (display[i] === true) {\n          requiredWidth += columns[i].minWidth;\n        }\n      } // Second pass, use up any remaining width for other columns. For\n      // scrolling tables we need to subtract the width of the scrollbar. It\n      // may not be requires which makes this sub-optimal, but it would\n      // require another full redraw to make complete use of those extra few\n      // pixels\n\n\n      var scrolling = dt.settings()[0].oScroll;\n      var bar = scrolling.sY || scrolling.sX ? scrolling.iBarWidth : 0;\n      var widthAvailable = dt.table().container().offsetWidth - bar;\n      var usedWidth = widthAvailable - requiredWidth; // Control column needs to always be included. This makes it sub-\n      // optimal in terms of using the available with, but to stop layout\n      // thrashing or overflow. Also we need to account for the control column\n      // width first so we know how much width is available for the other\n      // columns, since the control column might not be the first one shown\n\n      for (i = 0, ien = display.length; i < ien; i++) {\n        if (columns[i].control) {\n          usedWidth -= columns[i].minWidth;\n        }\n      } // Allow columns to be shown (counting by priority and then right to\n      // left) until we run out of room\n\n\n      var empty = false;\n\n      for (i = 0, ien = order.length; i < ien; i++) {\n        var colIdx = order[i].columnIdx;\n\n        if (display[colIdx] === '-' && !columns[colIdx].control && columns[colIdx].minWidth) {\n          // Once we've found a column that won't fit we don't let any\n          // others display either, or columns might disappear in the\n          // middle of the table\n          if (empty || usedWidth - columns[colIdx].minWidth < 0) {\n            empty = true;\n            display[colIdx] = false;\n          } else {\n            display[colIdx] = true;\n          }\n\n          usedWidth -= columns[colIdx].minWidth;\n        }\n      } // Determine if the 'control' column should be shown (if there is one).\n      // This is the case when there is a hidden column (that is not the\n      // control column). The two loops look inefficient here, but they are\n      // trivial and will fly through. We need to know the outcome from the\n      // first , before the action in the second can be taken\n\n\n      var showControl = false;\n\n      for (i = 0, ien = columns.length; i < ien; i++) {\n        if (!columns[i].control && !columns[i].never && display[i] === false) {\n          showControl = true;\n          break;\n        }\n      }\n\n      for (i = 0, ien = columns.length; i < ien; i++) {\n        if (columns[i].control) {\n          display[i] = showControl;\n        } // Replace not visible string with false from the control column detection above\n\n\n        if (display[i] === 'not-visible') {\n          display[i] = false;\n        }\n      } // Finally we need to make sure that there is at least one column that\n      // is visible\n\n\n      if ($.inArray(true, display) === -1) {\n        display[0] = true;\n      }\n\n      return display;\n    },\n\n    /**\n     * Create the internal `columns` array with information about the columns\n     * for the table. This includes determining which breakpoints the column\n     * will appear in, based upon class names in the column, which makes up the\n     * vast majority of this method.\n     *\n     * @private\n     */\n    _classLogic: function _classLogic() {\n      var that = this;\n      var calc = {};\n      var breakpoints = this.c.breakpoints;\n      var dt = this.s.dt;\n      var columns = dt.columns().eq(0).map(function (i) {\n        var column = this.column(i);\n        var className = column.header().className;\n        var priority = dt.settings()[0].aoColumns[i].responsivePriority;\n\n        if (priority === undefined) {\n          var dataPriority = $(column.header()).data('priority');\n          priority = dataPriority !== undefined ? dataPriority * 1 : 10000;\n        }\n\n        return {\n          className: className,\n          includeIn: [],\n          auto: false,\n          control: false,\n          never: className.match(/\\bnever\\b/) ? true : false,\n          priority: priority\n        };\n      }); // Simply add a breakpoint to `includeIn` array, ensuring that there are\n      // no duplicates\n\n      var add = function add(colIdx, name) {\n        var includeIn = columns[colIdx].includeIn;\n\n        if ($.inArray(name, includeIn) === -1) {\n          includeIn.push(name);\n        }\n      };\n\n      var column = function column(colIdx, name, operator, matched) {\n        var size, i, ien;\n\n        if (!operator) {\n          columns[colIdx].includeIn.push(name);\n        } else if (operator === 'max-') {\n          // Add this breakpoint and all smaller\n          size = that._find(name).width;\n\n          for (i = 0, ien = breakpoints.length; i < ien; i++) {\n            if (breakpoints[i].width <= size) {\n              add(colIdx, breakpoints[i].name);\n            }\n          }\n        } else if (operator === 'min-') {\n          // Add this breakpoint and all larger\n          size = that._find(name).width;\n\n          for (i = 0, ien = breakpoints.length; i < ien; i++) {\n            if (breakpoints[i].width >= size) {\n              add(colIdx, breakpoints[i].name);\n            }\n          }\n        } else if (operator === 'not-') {\n          // Add all but this breakpoint\n          for (i = 0, ien = breakpoints.length; i < ien; i++) {\n            if (breakpoints[i].name.indexOf(matched) === -1) {\n              add(colIdx, breakpoints[i].name);\n            }\n          }\n        }\n      }; // Loop over each column and determine if it has a responsive control\n      // class\n\n\n      columns.each(function (col, i) {\n        var classNames = col.className.split(' ');\n        var hasClass = false; // Split the class name up so multiple rules can be applied if needed\n\n        for (var k = 0, ken = classNames.length; k < ken; k++) {\n          var className = $.trim(classNames[k]);\n\n          if (className === 'all') {\n            // Include in all\n            hasClass = true;\n            col.includeIn = $.map(breakpoints, function (a) {\n              return a.name;\n            });\n            return;\n          } else if (className === 'none' || col.never) {\n            // Include in none (default) and no auto\n            hasClass = true;\n            return;\n          } else if (className === 'control') {\n            // Special column that is only visible, when one of the other\n            // columns is hidden. This is used for the details control\n            hasClass = true;\n            col.control = true;\n            return;\n          }\n\n          $.each(breakpoints, function (j, breakpoint) {\n            // Does this column have a class that matches this breakpoint?\n            var brokenPoint = breakpoint.name.split('-');\n            var re = new RegExp('(min\\\\-|max\\\\-|not\\\\-)?(' + brokenPoint[0] + ')(\\\\-[_a-zA-Z0-9])?');\n            var match = className.match(re);\n\n            if (match) {\n              hasClass = true;\n\n              if (match[2] === brokenPoint[0] && match[3] === '-' + brokenPoint[1]) {\n                // Class name matches breakpoint name fully\n                column(i, breakpoint.name, match[1], match[2] + match[3]);\n              } else if (match[2] === brokenPoint[0] && !match[3]) {\n                // Class name matched primary breakpoint name with no qualifier\n                column(i, breakpoint.name, match[1], match[2]);\n              }\n            }\n          });\n        } // If there was no control class, then automatic sizing is used\n\n\n        if (!hasClass) {\n          col.auto = true;\n        }\n      });\n      this.s.columns = columns;\n    },\n\n    /**\n     * Show the details for the child row\n     *\n     * @param  {DataTables.Api} row    API instance for the row\n     * @param  {boolean}        update Update flag\n     * @private\n     */\n    _detailsDisplay: function _detailsDisplay(row, update) {\n      var that = this;\n      var dt = this.s.dt;\n      var details = this.c.details;\n\n      if (details && details.type !== false) {\n        var res = details.display(row, update, function () {\n          return details.renderer(dt, row[0], that._detailsObj(row[0]));\n        });\n\n        if (res === true || res === false) {\n          $(dt.table().node()).triggerHandler('responsive-display.dt', [dt, row, res, update]);\n        }\n      }\n    },\n\n    /**\n     * Initialisation for the details handler\n     *\n     * @private\n     */\n    _detailsInit: function _detailsInit() {\n      var that = this;\n      var dt = this.s.dt;\n      var details = this.c.details; // The inline type always uses the first child as the target\n\n      if (details.type === 'inline') {\n        details.target = 'td:first-child, th:first-child';\n      } // Keyboard accessibility\n\n\n      dt.on('draw.dtr', function () {\n        that._tabIndexes();\n      });\n\n      that._tabIndexes(); // Initial draw has already happened\n\n\n      $(dt.table().body()).on('keyup.dtr', 'td, th', function (e) {\n        if (e.keyCode === 13 && $(this).data('dtr-keyboard')) {\n          $(this).click();\n        }\n      }); // type.target can be a string jQuery selector or a column index\n\n      var target = details.target;\n      var selector = typeof target === 'string' ? target : 'td, th'; // Click handler to show / hide the details rows when they are available\n\n      $(dt.table().body()).on('click.dtr mousedown.dtr mouseup.dtr', selector, function (e) {\n        // If the table is not collapsed (i.e. there is no hidden columns)\n        // then take no action\n        if (!$(dt.table().node()).hasClass('collapsed')) {\n          return;\n        } // Check that the row is actually a DataTable's controlled node\n\n\n        if ($.inArray($(this).closest('tr').get(0), dt.rows().nodes().toArray()) === -1) {\n          return;\n        } // For column index, we determine if we should act or not in the\n        // handler - otherwise it is already okay\n\n\n        if (typeof target === 'number') {\n          var targetIdx = target < 0 ? dt.columns().eq(0).length + target : target;\n\n          if (dt.cell(this).index().column !== targetIdx) {\n            return;\n          }\n        } // $().closest() includes itself in its check\n\n\n        var row = dt.row($(this).closest('tr')); // Check event type to do an action\n\n        if (e.type === 'click') {\n          // The renderer is given as a function so the caller can execute it\n          // only when they need (i.e. if hiding there is no point is running\n          // the renderer)\n          that._detailsDisplay(row, false);\n        } else if (e.type === 'mousedown') {\n          // For mouse users, prevent the focus ring from showing\n          $(this).css('outline', 'none');\n        } else if (e.type === 'mouseup') {\n          // And then re-allow at the end of the click\n          $(this).blur().css('outline', '');\n        }\n      });\n    },\n\n    /**\n     * Get the details to pass to a renderer for a row\n     * @param  {int} rowIdx Row index\n     * @private\n     */\n    _detailsObj: function _detailsObj(rowIdx) {\n      var that = this;\n      var dt = this.s.dt;\n      return $.map(this.s.columns, function (col, i) {\n        // Never and control columns should not be passed to the renderer\n        if (col.never || col.control) {\n          return;\n        }\n\n        return {\n          title: dt.settings()[0].aoColumns[i].sTitle,\n          data: dt.cell(rowIdx, i).render(that.c.orthogonal),\n          hidden: dt.column(i).visible() && !that.s.current[i],\n          columnIndex: i,\n          rowIndex: rowIdx\n        };\n      });\n    },\n\n    /**\n     * Find a breakpoint object from a name\n     *\n     * @param  {string} name Breakpoint name to find\n     * @return {object}      Breakpoint description object\n     * @private\n     */\n    _find: function _find(name) {\n      var breakpoints = this.c.breakpoints;\n\n      for (var i = 0, ien = breakpoints.length; i < ien; i++) {\n        if (breakpoints[i].name === name) {\n          return breakpoints[i];\n        }\n      }\n    },\n\n    /**\n     * Re-create the contents of the child rows as the display has changed in\n     * some way.\n     *\n     * @private\n     */\n    _redrawChildren: function _redrawChildren() {\n      var that = this;\n      var dt = this.s.dt;\n      dt.rows({\n        page: 'current'\n      }).iterator('row', function (settings, idx) {\n        var row = dt.row(idx);\n\n        that._detailsDisplay(dt.row(idx), true);\n      });\n    },\n\n    /**\n     * Alter the table display for a resized viewport. This involves first\n     * determining what breakpoint the window currently is in, getting the\n     * column visibilities to apply and then setting them.\n     *\n     * @private\n     */\n    _resize: function _resize() {\n      var that = this;\n      var dt = this.s.dt;\n      var width = $(window).width();\n      var breakpoints = this.c.breakpoints;\n      var breakpoint = breakpoints[0].name;\n      var columns = this.s.columns;\n      var i, ien;\n      var oldVis = this.s.current.slice(); // Determine what breakpoint we are currently at\n\n      for (i = breakpoints.length - 1; i >= 0; i--) {\n        if (width <= breakpoints[i].width) {\n          breakpoint = breakpoints[i].name;\n          break;\n        }\n      } // Show the columns for that break point\n\n\n      var columnsVis = this._columnsVisiblity(breakpoint);\n\n      this.s.current = columnsVis; // Set the class before the column visibility is changed so event\n      // listeners know what the state is. Need to determine if there are\n      // any columns that are not visible but can be shown\n\n      var collapsedClass = false;\n\n      for (i = 0, ien = columns.length; i < ien; i++) {\n        if (columnsVis[i] === false && !columns[i].never && !columns[i].control && !dt.column(i).visible() === false) {\n          collapsedClass = true;\n          break;\n        }\n      }\n\n      $(dt.table().node()).toggleClass('collapsed', collapsedClass);\n      var changed = false;\n      var visible = 0;\n      dt.columns().eq(0).each(function (colIdx, i) {\n        if (columnsVis[i] === true) {\n          visible++;\n        }\n\n        if (columnsVis[i] !== oldVis[i]) {\n          changed = true;\n\n          that._setColumnVis(colIdx, columnsVis[i]);\n        }\n      });\n\n      if (changed) {\n        this._redrawChildren(); // Inform listeners of the change\n\n\n        $(dt.table().node()).trigger('responsive-resize.dt', [dt, this.s.current]); // If no records, update the \"No records\" display element\n\n        if (dt.page.info().recordsDisplay === 0) {\n          $('td', dt.table().body()).eq(0).attr('colspan', visible);\n        }\n      }\n    },\n\n    /**\n     * Determine the width of each column in the table so the auto column hiding\n     * has that information to work with. This method is never going to be 100%\n     * perfect since column widths can change slightly per page, but without\n     * seriously compromising performance this is quite effective.\n     *\n     * @private\n     */\n    _resizeAuto: function _resizeAuto() {\n      var dt = this.s.dt;\n      var columns = this.s.columns; // Are we allowed to do auto sizing?\n\n      if (!this.c.auto) {\n        return;\n      } // Are there any columns that actually need auto-sizing, or do they all\n      // have classes defined\n\n\n      if ($.inArray(true, $.map(columns, function (c) {\n        return c.auto;\n      })) === -1) {\n        return;\n      } // Need to restore all children. They will be reinstated by a re-render\n\n\n      if (!$.isEmptyObject(_childNodeStore)) {\n        $.each(_childNodeStore, function (key) {\n          var idx = key.split('-');\n\n          _childNodesRestore(dt, idx[0] * 1, idx[1] * 1);\n        });\n      } // Clone the table with the current data in it\n\n\n      var tableWidth = dt.table().node().offsetWidth;\n      var columnWidths = dt.columns;\n      var clonedTable = dt.table().node().cloneNode(false);\n      var clonedHeader = $(dt.table().header().cloneNode(false)).appendTo(clonedTable);\n      var clonedBody = $(dt.table().body()).clone(false, false).empty().appendTo(clonedTable); // use jQuery because of IE8\n      // Header\n\n      var headerCells = dt.columns().header().filter(function (idx) {\n        return dt.column(idx).visible();\n      }).to$().clone(false).css('display', 'table-cell').css('min-width', 0); // Body rows - we don't need to take account of DataTables' column\n      // visibility since we implement our own here (hence the `display` set)\n\n      $(clonedBody).append($(dt.rows({\n        page: 'current'\n      }).nodes()).clone(false)).find('th, td').css('display', ''); // Footer\n\n      var footer = dt.table().footer();\n\n      if (footer) {\n        var clonedFooter = $(footer.cloneNode(false)).appendTo(clonedTable);\n        var footerCells = dt.columns().footer().filter(function (idx) {\n          return dt.column(idx).visible();\n        }).to$().clone(false).css('display', 'table-cell');\n        $('<tr/>').append(footerCells).appendTo(clonedFooter);\n      }\n\n      $('<tr/>').append(headerCells).appendTo(clonedHeader); // In the inline case extra padding is applied to the first column to\n      // give space for the show / hide icon. We need to use this in the\n      // calculation\n\n      if (this.c.details.type === 'inline') {\n        $(clonedTable).addClass('dtr-inline collapsed');\n      } // It is unsafe to insert elements with the same name into the DOM\n      // multiple times. For example, cloning and inserting a checked radio\n      // clears the chcecked state of the original radio.\n\n\n      $(clonedTable).find('[name]').removeAttr('name'); // A position absolute table would take the table out of the flow of\n      // our container element, bypassing the height and width (Scroller)\n\n      $(clonedTable).css('position', 'relative');\n      var inserted = $('<div/>').css({\n        width: 1,\n        height: 1,\n        overflow: 'hidden',\n        clear: 'both'\n      }).append(clonedTable);\n      inserted.insertBefore(dt.table().node()); // The cloned header now contains the smallest that each column can be\n\n      headerCells.each(function (i) {\n        var idx = dt.column.index('fromVisible', i);\n        columns[idx].minWidth = this.offsetWidth || 0;\n      });\n      inserted.remove();\n    },\n\n    /**\n     * Set a column's visibility.\n     *\n     * We don't use DataTables' column visibility controls in order to ensure\n     * that column visibility can Responsive can no-exist. Since only IE8+ is\n     * supported (and all evergreen browsers of course) the control of the\n     * display attribute works well.\n     *\n     * @param {integer} col      Column index\n     * @param {boolean} showHide Show or hide (true or false)\n     * @private\n     */\n    _setColumnVis: function _setColumnVis(col, showHide) {\n      var dt = this.s.dt;\n      var display = showHide ? '' : 'none'; // empty string will remove the attr\n\n      $(dt.column(col).header()).css('display', display);\n      $(dt.column(col).footer()).css('display', display);\n      dt.column(col).nodes().to$().css('display', display); // If the are child nodes stored, we might need to reinsert them\n\n      if (!$.isEmptyObject(_childNodeStore)) {\n        dt.cells(null, col).indexes().each(function (idx) {\n          _childNodesRestore(dt, idx.row, idx.column);\n        });\n      }\n    },\n\n    /**\n     * Update the cell tab indexes for keyboard accessibility. This is called on\n     * every table draw - that is potentially inefficient, but also the least\n     * complex option given that column visibility can change on the fly. Its a\n     * shame user-focus was removed from CSS 3 UI, as it would have solved this\n     * issue with a single CSS statement.\n     *\n     * @private\n     */\n    _tabIndexes: function _tabIndexes() {\n      var dt = this.s.dt;\n      var cells = dt.cells({\n        page: 'current'\n      }).nodes().to$();\n      var ctx = dt.settings()[0];\n      var target = this.c.details.target;\n      cells.filter('[data-dtr-keyboard]').removeData('[data-dtr-keyboard]');\n\n      if (typeof target === 'number') {\n        dt.cells(null, target, {\n          page: 'current'\n        }).nodes().to$().attr('tabIndex', ctx.iTabIndex).data('dtr-keyboard', 1);\n      } else {\n        // This is a bit of a hack - we need to limit the selected nodes to just\n        // those of this table\n        if (target === 'td:first-child, th:first-child') {\n          target = '>td:first-child, >th:first-child';\n        }\n\n        $(target, dt.rows({\n          page: 'current'\n        }).nodes()).attr('tabIndex', ctx.iTabIndex).data('dtr-keyboard', 1);\n      }\n    }\n  });\n  /**\n   * List of default breakpoints. Each item in the array is an object with two\n   * properties:\n   *\n   * * `name` - the breakpoint name.\n   * * `width` - the breakpoint width\n   *\n   * @name Responsive.breakpoints\n   * @static\n   */\n\n  Responsive.breakpoints = [{\n    name: 'desktop',\n    width: Infinity\n  }, {\n    name: 'tablet-l',\n    width: 1024\n  }, {\n    name: 'tablet-p',\n    width: 768\n  }, {\n    name: 'mobile-l',\n    width: 480\n  }, {\n    name: 'mobile-p',\n    width: 320\n  }];\n  /**\n   * Display methods - functions which define how the hidden data should be shown\n   * in the table.\n   *\n   * @namespace\n   * @name Responsive.defaults\n   * @static\n   */\n\n  Responsive.display = {\n    childRow: function childRow(row, update, render) {\n      if (update) {\n        if ($(row.node()).hasClass('parent')) {\n          row.child(render(), 'child').show();\n          return true;\n        }\n      } else {\n        if (!row.child.isShown()) {\n          row.child(render(), 'child').show();\n          $(row.node()).addClass('parent');\n          return true;\n        } else {\n          row.child(false);\n          $(row.node()).removeClass('parent');\n          return false;\n        }\n      }\n    },\n    childRowImmediate: function childRowImmediate(row, update, render) {\n      if (!update && row.child.isShown() || !row.responsive.hasHidden()) {\n        // User interaction and the row is show, or nothing to show\n        row.child(false);\n        $(row.node()).removeClass('parent');\n        return false;\n      } else {\n        // Display\n        row.child(render(), 'child').show();\n        $(row.node()).addClass('parent');\n        return true;\n      }\n    },\n    // This is a wrapper so the modal options for Bootstrap and jQuery UI can\n    // have options passed into them. This specific one doesn't need to be a\n    // function but it is for consistency in the `modal` name\n    modal: function modal(options) {\n      return function (row, update, render) {\n        if (!update) {\n          // Show a modal\n          var close = function close() {\n            modal.remove(); // will tidy events for us\n\n            $(document).off('keypress.dtr');\n          };\n\n          var modal = $('<div class=\"dtr-modal\"/>').append($('<div class=\"dtr-modal-display\"/>').append($('<div class=\"dtr-modal-content\"/>').append(render())).append($('<div class=\"dtr-modal-close\">&times;</div>').click(function () {\n            close();\n          }))).append($('<div class=\"dtr-modal-background\"/>').click(function () {\n            close();\n          })).appendTo('body');\n          $(document).on('keyup.dtr', function (e) {\n            if (e.keyCode === 27) {\n              e.stopPropagation();\n              close();\n            }\n          });\n        } else {\n          $('div.dtr-modal-content').empty().append(render());\n        }\n\n        if (options && options.header) {\n          $('div.dtr-modal-content').prepend('<h2>' + options.header(row) + '</h2>');\n        }\n      };\n    }\n  };\n  var _childNodeStore = {};\n\n  function _childNodes(dt, row, col) {\n    var name = row + '-' + col;\n\n    if (_childNodeStore[name]) {\n      return _childNodeStore[name];\n    } // https://jsperf.com/childnodes-array-slice-vs-loop\n\n\n    var nodes = [];\n    var children = dt.cell(row, col).node().childNodes;\n\n    for (var i = 0, ien = children.length; i < ien; i++) {\n      nodes.push(children[i]);\n    }\n\n    _childNodeStore[name] = nodes;\n    return nodes;\n  }\n\n  function _childNodesRestore(dt, row, col) {\n    var name = row + '-' + col;\n\n    if (!_childNodeStore[name]) {\n      return;\n    }\n\n    var node = dt.cell(row, col).node();\n    var store = _childNodeStore[name];\n    var parent = store[0].parentNode;\n    var parentChildren = parent.childNodes;\n    var a = [];\n\n    for (var i = 0, ien = parentChildren.length; i < ien; i++) {\n      a.push(parentChildren[i]);\n    }\n\n    for (var j = 0, jen = a.length; j < jen; j++) {\n      node.appendChild(a[j]);\n    }\n\n    _childNodeStore[name] = undefined;\n  }\n  /**\n   * Display methods - functions which define how the hidden data should be shown\n   * in the table.\n   *\n   * @namespace\n   * @name Responsive.defaults\n   * @static\n   */\n\n\n  Responsive.renderer = {\n    listHiddenNodes: function listHiddenNodes() {\n      return function (api, rowIdx, columns) {\n        var ul = $('<ul data-dtr-index=\"' + rowIdx + '\" class=\"dtr-details\"/>');\n        var found = false;\n        var data = $.each(columns, function (i, col) {\n          if (col.hidden) {\n            $('<li data-dtr-index=\"' + col.columnIndex + '\" data-dt-row=\"' + col.rowIndex + '\" data-dt-column=\"' + col.columnIndex + '\">' + '<span class=\"dtr-title\">' + col.title + '</span> ' + '</li>').append($('<span class=\"dtr-data\"/>').append(_childNodes(api, col.rowIndex, col.columnIndex))) // api.cell( col.rowIndex, col.columnIndex ).node().childNodes ) )\n            .appendTo(ul);\n            found = true;\n          }\n        });\n        return found ? ul : false;\n      };\n    },\n    listHidden: function listHidden() {\n      return function (api, rowIdx, columns) {\n        var data = $.map(columns, function (col) {\n          return col.hidden ? '<li data-dtr-index=\"' + col.columnIndex + '\" data-dt-row=\"' + col.rowIndex + '\" data-dt-column=\"' + col.columnIndex + '\">' + '<span class=\"dtr-title\">' + col.title + '</span> ' + '<span class=\"dtr-data\">' + col.data + '</span>' + '</li>' : '';\n        }).join('');\n        return data ? $('<ul data-dtr-index=\"' + rowIdx + '\" class=\"dtr-details\"/>').append(data) : false;\n      };\n    },\n    tableAll: function tableAll(options) {\n      options = $.extend({\n        tableClass: ''\n      }, options);\n      return function (api, rowIdx, columns) {\n        var data = $.map(columns, function (col) {\n          return '<tr data-dt-row=\"' + col.rowIndex + '\" data-dt-column=\"' + col.columnIndex + '\">' + '<td>' + col.title + ':' + '</td> ' + '<td>' + col.data + '</td>' + '</tr>';\n        }).join('');\n        return $('<table class=\"' + options.tableClass + ' dtr-details\" width=\"100%\"/>').append(data);\n      };\n    }\n  };\n  /**\n   * Responsive default settings for initialisation\n   *\n   * @namespace\n   * @name Responsive.defaults\n   * @static\n   */\n\n  Responsive.defaults = {\n    /**\n     * List of breakpoints for the instance. Note that this means that each\n     * instance can have its own breakpoints. Additionally, the breakpoints\n     * cannot be changed once an instance has been creased.\n     *\n     * @type {Array}\n     * @default Takes the value of `Responsive.breakpoints`\n     */\n    breakpoints: Responsive.breakpoints,\n\n    /**\n     * Enable / disable auto hiding calculations. It can help to increase\n     * performance slightly if you disable this option, but all columns would\n     * need to have breakpoint classes assigned to them\n     *\n     * @type {Boolean}\n     * @default  `true`\n     */\n    auto: true,\n\n    /**\n     * Details control. If given as a string value, the `type` property of the\n     * default object is set to that value, and the defaults used for the rest\n     * of the object - this is for ease of implementation.\n     *\n     * The object consists of the following properties:\n     *\n     * * `display` - A function that is used to show and hide the hidden details\n     * * `renderer` - function that is called for display of the child row data.\n     *   The default function will show the data from the hidden columns\n     * * `target` - Used as the selector for what objects to attach the child\n     *   open / close to\n     * * `type` - `false` to disable the details display, `inline` or `column`\n     *   for the two control types\n     *\n     * @type {Object|string}\n     */\n    details: {\n      display: Responsive.display.childRow,\n      renderer: Responsive.renderer.listHidden(),\n      target: 0,\n      type: 'inline'\n    },\n\n    /**\n     * Orthogonal data request option. This is used to define the data type\n     * requested when Responsive gets the data to show in the child row.\n     *\n     * @type {String}\n     */\n    orthogonal: 'display'\n  };\n  /*\n   * API\n   */\n\n  var Api = $.fn.dataTable.Api; // Doesn't do anything - work around for a bug in DT... Not documented\n\n  Api.register('responsive()', function () {\n    return this;\n  });\n  Api.register('responsive.index()', function (li) {\n    li = $(li);\n    return {\n      column: li.data('dtr-index'),\n      row: li.parent().data('dtr-index')\n    };\n  });\n  Api.register('responsive.rebuild()', function () {\n    return this.iterator('table', function (ctx) {\n      if (ctx._responsive) {\n        ctx._responsive._classLogic();\n      }\n    });\n  });\n  Api.register('responsive.recalc()', function () {\n    return this.iterator('table', function (ctx) {\n      if (ctx._responsive) {\n        ctx._responsive._resizeAuto();\n\n        ctx._responsive._resize();\n      }\n    });\n  });\n  Api.register('responsive.hasHidden()', function () {\n    var ctx = this.context[0];\n    return ctx._responsive ? $.inArray(false, ctx._responsive.s.current) !== -1 : false;\n  });\n  Api.registerPlural('columns().responsiveHidden()', 'column().responsiveHidden()', function () {\n    return this.iterator('column', function (settings, column) {\n      return settings._responsive ? settings._responsive.s.current[column] : false;\n    }, 1);\n  });\n  /**\n   * Version information\n   *\n   * @name Responsive.version\n   * @static\n   */\n\n  Responsive.version = '2.2.3';\n  $.fn.dataTable.Responsive = Responsive;\n  $.fn.DataTable.Responsive = Responsive; // Attach a listener to the document which listens for DataTables initialisation\n  // events so we can automatically initialise\n\n  $(document).on('preInit.dt.dtr', function (e, settings, json) {\n    if (e.namespace !== 'dt') {\n      return;\n    }\n\n    if ($(settings.nTable).hasClass('responsive') || $(settings.nTable).hasClass('dt-responsive') || settings.oInit.responsive || DataTable.defaults.responsive) {\n      var init = settings.oInit.responsive;\n\n      if (init !== false) {\n        new Responsive(settings, $.isPlainObject(init) ? init : {});\n      }\n    }\n  });\n  return Responsive;\n});","/*! Bootstrap integration for DataTables' Responsive\n * ©2015-2016 SpryMedia Ltd - datatables.net/license\n */\n(function (factory) {\n  if (typeof define === 'function' && define.amd) {\n    // AMD\n    define(['jquery', 'datatables.net-bs', 'datatables.net-responsive'], 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.net-bs')(root, $).$;\n      }\n\n      if (!$.fn.dataTable.Responsive) {\n        require('datatables.net-responsive')(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  var _display = DataTable.Responsive.display;\n  var _original = _display.modal;\n\n  var _modal = $('<div class=\"modal fade dtr-bs-modal\" role=\"dialog\">' + '<div class=\"modal-dialog\" role=\"document\">' + '<div class=\"modal-content\">' + '<div class=\"modal-header\">' + '<button type=\"button\" class=\"close\" data-dismiss=\"modal\" aria-label=\"Close\"><span aria-hidden=\"true\">&times;</span></button>' + '</div>' + '<div class=\"modal-body\"/>' + '</div>' + '</div>' + '</div>');\n\n  _display.modal = function (options) {\n    return function (row, update, render) {\n      if (!$.fn.modal) {\n        _original(row, update, render);\n      } else {\n        if (!update) {\n          if (options && options.header) {\n            var header = _modal.find('div.modal-header');\n\n            var button = header.find('button').detach();\n            header.empty().append('<h4 class=\"modal-title\">' + options.header(row) + '</h4>').prepend(button);\n          }\n\n          _modal.find('div.modal-body').empty().append(render());\n\n          _modal.appendTo('body').modal();\n        }\n      }\n    };\n  };\n\n  return DataTable.Responsive;\n});"],"sourceRoot":""}