react-mutation-mapper 0.9.3 → 0.9.5

package/dist/index.js

@@ -3,18 +3,17 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var tslib = require('tslib');
-var _ = require('lodash');
+var _$1 = require('lodash');
 var mobx = require('mobx');
 var mobxReact = require('mobx-react');
 var React = require('react');
 var cbioportalFrontendCommons = require('cbioportal-frontend-commons');
-var classNames = require('classnames');
+var classnames = require('classnames');
 var cbioportalUtils = require('cbioportal-utils');
 var oncokbFrontendCommons = require('oncokb-frontend-commons');
 var genomeNexusTsApiClient = require('genome-nexus-ts-api-client');
 var oncokbTsApiClient = require('oncokb-ts-api-client');
 var autobind = require('autobind-decorator');
-var ReactTable = require('react-table');
 require('rc-tooltip/assets/bootstrap_white.css');
 var Select = require('react-select');
 var $ = require('jquery');
@@ -48,13 +47,12 @@ function _interopNamespace(e) {
     return Object.freeze(n);
 }
 
-var ___default = /*#__PURE__*/_interopDefaultLegacy(_);
-var ___namespace = /*#__PURE__*/_interopNamespace(_);
+var ___default = /*#__PURE__*/_interopDefaultLegacy(_$1);
+var ___namespace = /*#__PURE__*/_interopNamespace(_$1);
 var React__namespace = /*#__PURE__*/_interopNamespace(React);
 var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
-var classNames__default = /*#__PURE__*/_interopDefaultLegacy(classNames);
+var classnames__default = /*#__PURE__*/_interopDefaultLegacy(classnames);
 var autobind__default = /*#__PURE__*/_interopDefaultLegacy(autobind);
-var ReactTable__default = /*#__PURE__*/_interopDefaultLegacy(ReactTable);
 var Select__default = /*#__PURE__*/_interopDefaultLegacy(Select);
 var $__default = /*#__PURE__*/_interopDefaultLegacy($);
 var numeral__default = /*#__PURE__*/_interopDefaultLegacy(numeral);
@@ -66,7 +64,7 @@ var memoize__default = /*#__PURE__*/_interopDefaultLegacy(memoize);
 var annotationStyles = {"annotation-item-load":"annotation-module_annotation-item-load__1pDN0","annotation-item-text":"annotation-module_annotation-item-text__Gy_Jv","annotation-item-error":"annotation-module_annotation-item-error__5BhTo","annotation-item":"annotation-module_annotation-item__2EgnB"};
 
 function loaderIcon(className) {
-    return (React__namespace.createElement("span", { className: classNames__default["default"]("".concat(annotationStyles['annotation-item']), "".concat(annotationStyles['annotation-item-load']), className) },
+    return (React__namespace.createElement("span", { className: classnames__default["default"]("".concat(annotationStyles['annotation-item']), "".concat(annotationStyles['annotation-item-load']), className) },
         React__namespace.createElement("i", { className: "fa fa-spinner fa-pulse" })));
 }
 function errorIcon(errorMessage) {
@@ -1104,6 +1102,3856 @@ function generateGnomadUrl(chromosome, position, reference, variant) {
     }
 }
 
+var _extends$4 = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+function _objectWithoutProperties$1(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
+//
+var _ = {
+  get: get,
+  set: set,
+  takeRight: takeRight,
+  last: last,
+  orderBy: orderBy,
+  range: range,
+  remove: remove,
+  clone: clone,
+  getFirstDefined: getFirstDefined,
+  sum: sum,
+  makeTemplateComponent: makeTemplateComponent,
+  groupBy: groupBy,
+  isArray: isArray,
+  splitProps: splitProps,
+  compactObject: compactObject,
+  isSortingDesc: isSortingDesc,
+  normalizeComponent: normalizeComponent,
+  asPx: asPx
+};
+
+function get(obj, path, def) {
+  if (!path) {
+    return obj;
+  }
+  var pathObj = makePathArray(path);
+  var val = void 0;
+  try {
+    val = pathObj.reduce(function (current, pathPart) {
+      return current[pathPart];
+    }, obj);
+  } catch (e) {
+    // continue regardless of error
+  }
+  return typeof val !== 'undefined' ? val : def;
+}
+
+function set() {
+  var obj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var path = arguments[1];
+  var value = arguments[2];
+
+  var keys = makePathArray(path);
+  var keyPart = void 0;
+  var cursor = obj;
+  while ((keyPart = keys.shift()) && keys.length) {
+    if (!cursor[keyPart]) {
+      cursor[keyPart] = {};
+    }
+    cursor = cursor[keyPart];
+  }
+  cursor[keyPart] = value;
+  return obj;
+}
+
+function takeRight(arr, n) {
+  var start = n > arr.length ? 0 : arr.length - n;
+  return arr.slice(start);
+}
+
+function last(arr) {
+  return arr[arr.length - 1];
+}
+
+function range(n) {
+  var arr = [];
+  for (var i = 0; i < n; i += 1) {
+    arr.push(n);
+  }
+  return arr;
+}
+
+function orderBy(arr, funcs, dirs, indexKey) {
+  return arr.sort(function (rowA, rowB) {
+    for (var i = 0; i < funcs.length; i += 1) {
+      var comp = funcs[i];
+      var desc = dirs[i] === false || dirs[i] === 'desc';
+      var sortInt = comp(rowA, rowB);
+      if (sortInt) {
+        return desc ? -sortInt : sortInt;
+      }
+    }
+    // Use the row index for tie breakers
+    return dirs[0] ? rowA[indexKey] - rowB[indexKey] : rowB[indexKey] - rowA[indexKey];
+  });
+}
+
+function remove(a, b) {
+  return a.filter(function (o, i) {
+    var r = b(o);
+    if (r) {
+      a.splice(i, 1);
+      return true;
+    }
+    return false;
+  });
+}
+
+function clone(a) {
+  try {
+    return JSON.parse(JSON.stringify(a, function (key, value) {
+      if (typeof value === 'function') {
+        return value.toString();
+      }
+      return value;
+    }));
+  } catch (e) {
+    return a;
+  }
+}
+
+function getFirstDefined() {
+  for (var i = 0; i < arguments.length; i += 1) {
+    if (typeof (arguments.length <= i ? undefined : arguments[i]) !== 'undefined') {
+      return arguments.length <= i ? undefined : arguments[i];
+    }
+  }
+}
+
+function sum(arr) {
+  return arr.reduce(function (a, b) {
+    return a + b;
+  }, 0);
+}
+
+function makeTemplateComponent(compClass, displayName) {
+  if (!displayName) {
+    throw new Error('No displayName found for template component:', compClass);
+  }
+  var cmp = function cmp(_ref) {
+    var children = _ref.children,
+        className = _ref.className,
+        rest = _objectWithoutProperties$1(_ref, ['children', 'className']);
+
+    return React__default["default"].createElement(
+      'div',
+      _extends$4({ className: classnames__default["default"](compClass, className) }, rest),
+      children
+    );
+  };
+  cmp.displayName = displayName;
+  return cmp;
+}
+
+function groupBy(xs, key) {
+  return xs.reduce(function (rv, x, i) {
+    var resKey = typeof key === 'function' ? key(x, i) : x[key];
+    rv[resKey] = isArray(rv[resKey]) ? rv[resKey] : [];
+    rv[resKey].push(x);
+    return rv;
+  }, {});
+}
+
+function asPx(value) {
+  value = Number(value);
+  return Number.isNaN(value) ? null : value + 'px';
+}
+
+function isArray(a) {
+  return Array.isArray(a);
+}
+
+// ########################################################################
+// Non-exported Helpers
+// ########################################################################
+
+function makePathArray(obj) {
+  return flattenDeep(obj).join('.').replace(/\[/g, '.').replace(/\]/g, '').split('.');
+}
+
+function flattenDeep(arr) {
+  var newArr = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+
+  if (!isArray(arr)) {
+    newArr.push(arr);
+  } else {
+    for (var i = 0; i < arr.length; i += 1) {
+      flattenDeep(arr[i], newArr);
+    }
+  }
+  return newArr;
+}
+
+function splitProps(_ref2) {
+  var className = _ref2.className,
+      style = _ref2.style,
+      rest = _objectWithoutProperties$1(_ref2, ['className', 'style']);
+
+  return {
+    className: className,
+    style: style,
+    rest: rest || {}
+  };
+}
+
+function compactObject(obj) {
+  var newObj = {};
+  if (obj) {
+    Object.keys(obj).map(function (key) {
+      if (Object.prototype.hasOwnProperty.call(obj, key) && obj[key] !== undefined && typeof obj[key] !== 'undefined') {
+        newObj[key] = obj[key];
+      }
+      return true;
+    });
+  }
+  return newObj;
+}
+
+function isSortingDesc(d) {
+  return !!(d.sort === 'desc' || d.desc === true || d.asc === false);
+}
+
+function normalizeComponent(Comp) {
+  var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var fallback = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Comp;
+
+  return typeof Comp === 'function' ? React__default["default"].createElement(Comp, params) : fallback;
+}
+
+var _createClass$3 = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck$3(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn$3(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits$3(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Lifecycle = (function (Base) {
+  return function (_Base) {
+    _inherits$3(_class, _Base);
+
+    function _class() {
+      _classCallCheck$3(this, _class);
+
+      return _possibleConstructorReturn$3(this, (_class.__proto__ || Object.getPrototypeOf(_class)).apply(this, arguments));
+    }
+
+    _createClass$3(_class, [{
+      key: 'componentWillMount',
+      value: function componentWillMount() {
+        this.setStateWithData(this.getDataModel(this.getResolvedState(), true));
+      }
+    }, {
+      key: 'componentDidMount',
+      value: function componentDidMount() {
+        this.fireFetchData();
+      }
+    }, {
+      key: 'componentWillReceiveProps',
+      value: function componentWillReceiveProps(nextProps, nextState) {
+        var oldState = this.getResolvedState();
+        var newState = this.getResolvedState(nextProps, nextState);
+
+        // Do a deep compare of new and old `defaultOption` and
+        // if they are different reset `option = defaultOption`
+        var defaultableOptions = ['sorted', 'filtered', 'resized', 'expanded'];
+        defaultableOptions.forEach(function (x) {
+          var defaultName = 'default' + (x.charAt(0).toUpperCase() + x.slice(1));
+          if (JSON.stringify(oldState[defaultName]) !== JSON.stringify(newState[defaultName])) {
+            newState[x] = newState[defaultName];
+          }
+        });
+
+        // If they change these table options, we need to reset defaults
+        // or else we could get into a state where the user has changed the UI
+        // and then disabled the ability to change it back.
+        // e.g. If `filterable` has changed, set `filtered = defaultFiltered`
+        var resettableOptions = ['sortable', 'filterable', 'resizable'];
+        resettableOptions.forEach(function (x) {
+          if (oldState[x] !== newState[x]) {
+            var baseName = x.replace('able', '');
+            var optionName = baseName + 'ed';
+            var defaultName = 'default' + (optionName.charAt(0).toUpperCase() + optionName.slice(1));
+            newState[optionName] = newState[defaultName];
+          }
+        });
+
+        // Props that trigger a data update
+        if (oldState.data !== newState.data || oldState.columns !== newState.columns || oldState.pivotBy !== newState.pivotBy || oldState.sorted !== newState.sorted || oldState.filtered !== newState.filtered) {
+          this.setStateWithData(this.getDataModel(newState, oldState.data !== newState.data));
+        }
+      }
+    }, {
+      key: 'setStateWithData',
+      value: function setStateWithData(newState, cb) {
+        var _this2 = this;
+
+        var oldState = this.getResolvedState();
+        var newResolvedState = this.getResolvedState({}, newState);
+        var freezeWhenExpanded = newResolvedState.freezeWhenExpanded;
+
+        // Default to unfrozen state
+
+        newResolvedState.frozen = false;
+
+        // If freezeWhenExpanded is set, check for frozen conditions
+        if (freezeWhenExpanded) {
+          // if any rows are expanded, freeze the existing data and sorting
+          var keys = Object.keys(newResolvedState.expanded);
+          for (var i = 0; i < keys.length; i += 1) {
+            if (newResolvedState.expanded[keys[i]]) {
+              newResolvedState.frozen = true;
+              break;
+            }
+          }
+        }
+
+        // If the data isn't frozen and either the data or
+        // sorting model has changed, update the data
+        if (oldState.frozen && !newResolvedState.frozen || oldState.sorted !== newResolvedState.sorted || oldState.filtered !== newResolvedState.filtered || oldState.showFilters !== newResolvedState.showFilters || !newResolvedState.frozen && oldState.resolvedData !== newResolvedState.resolvedData) {
+          // Handle collapseOnsortedChange & collapseOnDataChange
+          if (oldState.sorted !== newResolvedState.sorted && this.props.collapseOnSortingChange || oldState.filtered !== newResolvedState.filtered || oldState.showFilters !== newResolvedState.showFilters || oldState.sortedData && !newResolvedState.frozen && oldState.resolvedData !== newResolvedState.resolvedData && this.props.collapseOnDataChange) {
+            newResolvedState.expanded = {};
+          }
+
+          Object.assign(newResolvedState, this.getSortedData(newResolvedState));
+        }
+
+        // Set page to 0 if filters change
+        if (oldState.filtered !== newResolvedState.filtered) {
+          newResolvedState.page = 0;
+        }
+
+        // Calculate pageSize all the time
+        if (newResolvedState.sortedData) {
+          newResolvedState.pages = newResolvedState.manual ? newResolvedState.pages : Math.ceil(newResolvedState.sortedData.length / newResolvedState.pageSize);
+          newResolvedState.page = newResolvedState.manual ? newResolvedState.page : Math.max(newResolvedState.page >= newResolvedState.pages ? newResolvedState.pages - 1 : newResolvedState.page, 0);
+        }
+
+        return this.setState(newResolvedState, function () {
+          if (cb) {
+            cb();
+          }
+          if (oldState.page !== newResolvedState.page || oldState.pageSize !== newResolvedState.pageSize || oldState.sorted !== newResolvedState.sorted || oldState.filtered !== newResolvedState.filtered) {
+            _this2.fireFetchData();
+          }
+        });
+      }
+    }]);
+
+    return _class;
+  }(Base);
+});
+
+var _slicedToArray$1 = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
+
+var _extends$3 = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var _createClass$2 = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+function _classCallCheck$2(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn$2(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits$2(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var Methods = (function (Base) {
+  return function (_Base) {
+    _inherits$2(_class, _Base);
+
+    function _class() {
+      _classCallCheck$2(this, _class);
+
+      return _possibleConstructorReturn$2(this, (_class.__proto__ || Object.getPrototypeOf(_class)).apply(this, arguments));
+    }
+
+    _createClass$2(_class, [{
+      key: 'getResolvedState',
+      value: function getResolvedState(props, state) {
+        var resolvedState = _extends$3({}, _.compactObject(this.state), _.compactObject(this.props), _.compactObject(state), _.compactObject(props));
+        return resolvedState;
+      }
+    }, {
+      key: 'getDataModel',
+      value: function getDataModel(newState, dataChanged) {
+        var _this2 = this;
+
+        var columns = newState.columns,
+            _newState$pivotBy = newState.pivotBy,
+            pivotBy = _newState$pivotBy === undefined ? [] : _newState$pivotBy,
+            data = newState.data,
+            resolveData = newState.resolveData,
+            pivotIDKey = newState.pivotIDKey,
+            pivotValKey = newState.pivotValKey,
+            subRowsKey = newState.subRowsKey,
+            aggregatedKey = newState.aggregatedKey,
+            nestingLevelKey = newState.nestingLevelKey,
+            originalKey = newState.originalKey,
+            indexKey = newState.indexKey,
+            groupedByPivotKey = newState.groupedByPivotKey,
+            SubComponent = newState.SubComponent;
+
+        // Determine Header Groups
+
+        var hasHeaderGroups = false;
+        columns.forEach(function (column) {
+          if (column.columns) {
+            hasHeaderGroups = true;
+          }
+        });
+
+        var columnsWithExpander = [].concat(_toConsumableArray(columns));
+
+        var expanderColumn = columns.find(function (col) {
+          return col.expander || col.columns && col.columns.some(function (col2) {
+            return col2.expander;
+          });
+        });
+        // The actual expander might be in the columns field of a group column
+        if (expanderColumn && !expanderColumn.expander) {
+          expanderColumn = expanderColumn.columns.find(function (col) {
+            return col.expander;
+          });
+        }
+
+        // If we have SubComponent's we need to make sure we have an expander column
+        if (SubComponent && !expanderColumn) {
+          expanderColumn = { expander: true };
+          columnsWithExpander = [expanderColumn].concat(_toConsumableArray(columnsWithExpander));
+        }
+
+        var makeDecoratedColumn = function makeDecoratedColumn(column, parentColumn) {
+          var dcol = void 0;
+          if (column.expander) {
+            dcol = _extends$3({}, _this2.props.column, _this2.props.expanderDefaults, column);
+          } else {
+            dcol = _extends$3({}, _this2.props.column, column);
+          }
+
+          // Ensure minWidth is not greater than maxWidth if set
+          if (dcol.maxWidth < dcol.minWidth) {
+            dcol.minWidth = dcol.maxWidth;
+          }
+
+          if (parentColumn) {
+            dcol.parentColumn = parentColumn;
+          }
+
+          // First check for string accessor
+          if (typeof dcol.accessor === 'string') {
+            dcol.id = dcol.id || dcol.accessor;
+            var accessorString = dcol.accessor;
+            dcol.accessor = function (row) {
+              return _.get(row, accessorString);
+            };
+            return dcol;
+          }
+
+          // Fall back to functional accessor (but require an ID)
+          if (dcol.accessor && !dcol.id) {
+            console.warn(dcol);
+            throw new Error('A column id is required if using a non-string accessor for column above.');
+          }
+
+          // Fall back to an undefined accessor
+          if (!dcol.accessor) {
+            dcol.accessor = function () {
+              return undefined;
+            };
+          }
+
+          return dcol;
+        };
+
+        var allDecoratedColumns = [];
+
+        // Decorate the columns
+        var decorateAndAddToAll = function decorateAndAddToAll(column, parentColumn) {
+          var decoratedColumn = makeDecoratedColumn(column, parentColumn);
+          allDecoratedColumns.push(decoratedColumn);
+          return decoratedColumn;
+        };
+
+        var decoratedColumns = columnsWithExpander.map(function (column) {
+          if (column.columns) {
+            return _extends$3({}, column, {
+              columns: column.columns.map(function (d) {
+                return decorateAndAddToAll(d, column);
+              })
+            });
+          }
+          return decorateAndAddToAll(column);
+        });
+
+        // Build the visible columns, headers and flat column list
+        var visibleColumns = decoratedColumns.slice();
+        var allVisibleColumns = [];
+
+        visibleColumns = visibleColumns.map(function (column) {
+          if (column.columns) {
+            var visibleSubColumns = column.columns.filter(function (d) {
+              return pivotBy.indexOf(d.id) > -1 ? false : _.getFirstDefined(d.show, true);
+            });
+            return _extends$3({}, column, {
+              columns: visibleSubColumns
+            });
+          }
+          return column;
+        });
+
+        visibleColumns = visibleColumns.filter(function (column) {
+          return column.columns ? column.columns.length : pivotBy.indexOf(column.id) > -1 ? false : _.getFirstDefined(column.show, true);
+        });
+
+        // Find any custom pivot location
+        var pivotIndex = visibleColumns.findIndex(function (col) {
+          return col.pivot;
+        });
+
+        // Handle Pivot Columns
+        if (pivotBy.length) {
+          // Retrieve the pivot columns in the correct pivot order
+          var pivotColumns = [];
+          pivotBy.forEach(function (pivotID) {
+            var found = allDecoratedColumns.find(function (d) {
+              return d.id === pivotID;
+            });
+            if (found) {
+              pivotColumns.push(found);
+            }
+          });
+
+          var PivotParentColumn = pivotColumns.reduce(function (prev, current) {
+            return prev && prev === current.parentColumn && current.parentColumn;
+          }, pivotColumns[0].parentColumn);
+
+          var PivotGroupHeader = hasHeaderGroups && PivotParentColumn.Header;
+          PivotGroupHeader = PivotGroupHeader || function () {
+            return React__default["default"].createElement(
+              'strong',
+              null,
+              'Pivoted'
+            );
+          };
+
+          var pivotColumnGroup = {
+            Header: PivotGroupHeader,
+            columns: pivotColumns.map(function (col) {
+              return _extends$3({}, _this2.props.pivotDefaults, col, {
+                pivoted: true
+              });
+            })
+
+            // Place the pivotColumns back into the visibleColumns
+          };if (pivotIndex >= 0) {
+            pivotColumnGroup = _extends$3({}, visibleColumns[pivotIndex], pivotColumnGroup);
+            visibleColumns.splice(pivotIndex, 1, pivotColumnGroup);
+          } else {
+            visibleColumns.unshift(pivotColumnGroup);
+          }
+        }
+
+        // Build Header Groups
+        var headerGroups = [];
+        var currentSpan = [];
+
+        // A convenience function to add a header and reset the currentSpan
+        var addHeader = function addHeader(columns, column) {
+          headerGroups.push(_extends$3({}, _this2.props.column, column, {
+            columns: columns
+          }));
+          currentSpan = [];
+        };
+
+        // Build flast list of allVisibleColumns and HeaderGroups
+        visibleColumns.forEach(function (column) {
+          if (column.columns) {
+            allVisibleColumns = allVisibleColumns.concat(column.columns);
+            if (currentSpan.length > 0) {
+              addHeader(currentSpan);
+            }
+            addHeader(column.columns, column);
+            return;
+          }
+          allVisibleColumns.push(column);
+          currentSpan.push(column);
+        });
+        if (hasHeaderGroups && currentSpan.length > 0) {
+          addHeader(currentSpan);
+        }
+
+        // Access the data
+        var accessRow = function accessRow(d, i) {
+          var _row;
+
+          var level = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+
+          var row = (_row = {}, _defineProperty(_row, originalKey, d), _defineProperty(_row, indexKey, i), _defineProperty(_row, subRowsKey, d[subRowsKey]), _defineProperty(_row, nestingLevelKey, level), _row);
+          allDecoratedColumns.forEach(function (column) {
+            if (column.expander) return;
+            row[column.id] = column.accessor(d);
+          });
+          if (row[subRowsKey]) {
+            row[subRowsKey] = row[subRowsKey].map(function (d, i) {
+              return accessRow(d, i, level + 1);
+            });
+          }
+          return row;
+        };
+
+        // // If the data hasn't changed, just use the cached data
+        var resolvedData = this.resolvedData;
+        // If the data has changed, run the data resolver and cache the result
+        if (!this.resolvedData || dataChanged) {
+          resolvedData = resolveData(data);
+          this.resolvedData = resolvedData;
+        }
+        // Use the resolved data
+        resolvedData = resolvedData.map(function (d, i) {
+          return accessRow(d, i);
+        });
+
+        // TODO: Make it possible to fabricate nested rows without pivoting
+        var aggregatingColumns = allVisibleColumns.filter(function (d) {
+          return !d.expander && d.aggregate;
+        });
+
+        // If pivoting, recursively group the data
+        var aggregate = function aggregate(rows) {
+          var aggregationValues = {};
+          aggregatingColumns.forEach(function (column) {
+            var values = rows.map(function (d) {
+              return d[column.id];
+            });
+            aggregationValues[column.id] = column.aggregate(values, rows);
+          });
+          return aggregationValues;
+        };
+        if (pivotBy.length) {
+          var groupRecursively = function groupRecursively(rows, keys) {
+            var i = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+
+            // This is the last level, just return the rows
+            if (i === keys.length) {
+              return rows;
+            }
+            // Group the rows together for this level
+            var groupedRows = Object.entries(_.groupBy(rows, keys[i])).map(function (_ref) {
+              var _ref3;
+
+              var _ref2 = _slicedToArray$1(_ref, 2),
+                  key = _ref2[0],
+                  value = _ref2[1];
+
+              return _ref3 = {}, _defineProperty(_ref3, pivotIDKey, keys[i]), _defineProperty(_ref3, pivotValKey, key), _defineProperty(_ref3, keys[i], key), _defineProperty(_ref3, subRowsKey, value), _defineProperty(_ref3, nestingLevelKey, i), _defineProperty(_ref3, groupedByPivotKey, true), _ref3;
+            });
+            // Recurse into the subRows
+            groupedRows = groupedRows.map(function (rowGroup) {
+              var _extends2;
+
+              var subRows = groupRecursively(rowGroup[subRowsKey], keys, i + 1);
+              return _extends$3({}, rowGroup, (_extends2 = {}, _defineProperty(_extends2, subRowsKey, subRows), _defineProperty(_extends2, aggregatedKey, true), _extends2), aggregate(subRows));
+            });
+            return groupedRows;
+          };
+          resolvedData = groupRecursively(resolvedData, pivotBy);
+        }
+
+        return _extends$3({}, newState, {
+          resolvedData: resolvedData,
+          allVisibleColumns: allVisibleColumns,
+          headerGroups: headerGroups,
+          allDecoratedColumns: allDecoratedColumns,
+          hasHeaderGroups: hasHeaderGroups
+        });
+      }
+    }, {
+      key: 'getSortedData',
+      value: function getSortedData(resolvedState) {
+        var manual = resolvedState.manual,
+            sorted = resolvedState.sorted,
+            filtered = resolvedState.filtered,
+            defaultFilterMethod = resolvedState.defaultFilterMethod,
+            resolvedData = resolvedState.resolvedData,
+            allDecoratedColumns = resolvedState.allDecoratedColumns;
+
+
+        var sortMethodsByColumnID = {};
+
+        allDecoratedColumns.filter(function (col) {
+          return col.sortMethod;
+        }).forEach(function (col) {
+          sortMethodsByColumnID[col.id] = col.sortMethod;
+        });
+
+        // Resolve the data from either manual data or sorted data
+        return {
+          sortedData: manual ? resolvedData : this.sortData(this.filterData(resolvedData, filtered, defaultFilterMethod, allDecoratedColumns), sorted, sortMethodsByColumnID)
+        };
+      }
+    }, {
+      key: 'fireFetchData',
+      value: function fireFetchData() {
+        // determine the current state, preferring certain state values over props
+        var currentState = _extends$3({}, this.getResolvedState(), {
+          page: this.getStateOrProp('page'),
+          pageSize: this.getStateOrProp('pageSize'),
+          filter: this.getStateOrProp('filter')
+        });
+
+        this.props.onFetchData(currentState, this);
+      }
+    }, {
+      key: 'getPropOrState',
+      value: function getPropOrState(key) {
+        return _.getFirstDefined(this.props[key], this.state[key]);
+      }
+    }, {
+      key: 'getStateOrProp',
+      value: function getStateOrProp(key) {
+        return _.getFirstDefined(this.state[key], this.props[key]);
+      }
+    }, {
+      key: 'filterData',
+      value: function filterData(data, filtered, defaultFilterMethod, allVisibleColumns) {
+        var _this3 = this;
+
+        var filteredData = data;
+
+        if (filtered.length) {
+          filteredData = filtered.reduce(function (filteredSoFar, nextFilter) {
+            var column = allVisibleColumns.find(function (x) {
+              return x.id === nextFilter.id;
+            });
+
+            // Don't filter hidden columns or columns that have had their filters disabled
+            if (!column || column.filterable === false) {
+              return filteredSoFar;
+            }
+
+            var filterMethod = column.filterMethod || defaultFilterMethod;
+
+            // If 'filterAll' is set to true, pass the entire dataset to the filter method
+            if (column.filterAll) {
+              return filterMethod(nextFilter, filteredSoFar, column);
+            }
+            return filteredSoFar.filter(function (row) {
+              return filterMethod(nextFilter, row, column);
+            });
+          }, filteredData);
+
+          // Apply the filter to the subrows if we are pivoting, and then
+          // filter any rows without subcolumns because it would be strange to show
+          filteredData = filteredData.map(function (row) {
+            if (!row[_this3.props.subRowsKey]) {
+              return row;
+            }
+            return _extends$3({}, row, _defineProperty({}, _this3.props.subRowsKey, _this3.filterData(row[_this3.props.subRowsKey], filtered, defaultFilterMethod, allVisibleColumns)));
+          }).filter(function (row) {
+            if (!row[_this3.props.subRowsKey]) {
+              return true;
+            }
+            return row[_this3.props.subRowsKey].length > 0;
+          });
+        }
+
+        return filteredData;
+      }
+    }, {
+      key: 'sortData',
+      value: function sortData(data, sorted) {
+        var _this4 = this;
+
+        var sortMethodsByColumnID = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+
+        if (!sorted.length) {
+          return data;
+        }
+
+        var sortedData = (this.props.orderByMethod || _.orderBy)(data, sorted.map(function (sort) {
+          // Support custom sorting methods for each column
+          if (sortMethodsByColumnID[sort.id]) {
+            return function (a, b) {
+              return sortMethodsByColumnID[sort.id](a[sort.id], b[sort.id], sort.desc);
+            };
+          }
+          return function (a, b) {
+            return _this4.props.defaultSortMethod(a[sort.id], b[sort.id], sort.desc);
+          };
+        }), sorted.map(function (d) {
+          return !d.desc;
+        }), this.props.indexKey);
+
+        sortedData.forEach(function (row) {
+          if (!row[_this4.props.subRowsKey]) {
+            return;
+          }
+          row[_this4.props.subRowsKey] = _this4.sortData(row[_this4.props.subRowsKey], sorted, sortMethodsByColumnID);
+        });
+
+        return sortedData;
+      }
+    }, {
+      key: 'getMinRows',
+      value: function getMinRows() {
+        return _.getFirstDefined(this.props.minRows, this.getStateOrProp('pageSize'));
+      }
+
+      // User actions
+
+    }, {
+      key: 'onPageChange',
+      value: function onPageChange(page) {
+        var _props = this.props,
+            onPageChange = _props.onPageChange,
+            collapseOnPageChange = _props.collapseOnPageChange;
+
+
+        var newState = { page: page };
+        if (collapseOnPageChange) {
+          newState.expanded = {};
+        }
+        this.setStateWithData(newState, function () {
+          return onPageChange && onPageChange(page);
+        });
+      }
+    }, {
+      key: 'onPageSizeChange',
+      value: function onPageSizeChange(newPageSize) {
+        var onPageSizeChange = this.props.onPageSizeChange;
+
+        var _getResolvedState = this.getResolvedState(),
+            pageSize = _getResolvedState.pageSize,
+            page = _getResolvedState.page;
+
+        // Normalize the page to display
+
+
+        var currentRow = pageSize * page;
+        var newPage = Math.floor(currentRow / newPageSize);
+
+        this.setStateWithData({
+          pageSize: newPageSize,
+          page: newPage
+        }, function () {
+          return onPageSizeChange && onPageSizeChange(newPageSize, newPage);
+        });
+      }
+    }, {
+      key: 'sortColumn',
+      value: function sortColumn(column, additive) {
+        var _getResolvedState2 = this.getResolvedState(),
+            sorted = _getResolvedState2.sorted,
+            skipNextSort = _getResolvedState2.skipNextSort,
+            defaultSortDesc = _getResolvedState2.defaultSortDesc;
+
+        var firstSortDirection = Object.prototype.hasOwnProperty.call(column, 'defaultSortDesc') ? column.defaultSortDesc : defaultSortDesc;
+        var secondSortDirection = !firstSortDirection;
+
+        // we can't stop event propagation from the column resize move handlers
+        // attached to the document because of react's synthetic events
+        // so we have to prevent the sort function from actually sorting
+        // if we click on the column resize element within a header.
+        if (skipNextSort) {
+          this.setStateWithData({
+            skipNextSort: false
+          });
+          return;
+        }
+
+        var onSortedChange = this.props.onSortedChange;
+
+
+        var newSorted = _.clone(sorted || []).map(function (d) {
+          d.desc = _.isSortingDesc(d);
+          return d;
+        });
+        if (!_.isArray(column)) {
+          // Single-Sort
+          var existingIndex = newSorted.findIndex(function (d) {
+            return d.id === column.id;
+          });
+          if (existingIndex > -1) {
+            var existing = newSorted[existingIndex];
+            if (existing.desc === secondSortDirection) {
+              if (additive) {
+                newSorted.splice(existingIndex, 1);
+              } else {
+                existing.desc = firstSortDirection;
+                newSorted = [existing];
+              }
+            } else {
+              existing.desc = secondSortDirection;
+              if (!additive) {
+                newSorted = [existing];
+              }
+            }
+          } else if (additive) {
+            newSorted.push({
+              id: column.id,
+              desc: firstSortDirection
+            });
+          } else {
+            newSorted = [{
+              id: column.id,
+              desc: firstSortDirection
+            }];
+          }
+        } else {
+          // Multi-Sort
+          var _existingIndex = newSorted.findIndex(function (d) {
+            return d.id === column[0].id;
+          });
+          // Existing Sorted Column
+          if (_existingIndex > -1) {
+            var _existing = newSorted[_existingIndex];
+            if (_existing.desc === secondSortDirection) {
+              if (additive) {
+                newSorted.splice(_existingIndex, column.length);
+              } else {
+                column.forEach(function (d, i) {
+                  newSorted[_existingIndex + i].desc = firstSortDirection;
+                });
+              }
+            } else {
+              column.forEach(function (d, i) {
+                newSorted[_existingIndex + i].desc = secondSortDirection;
+              });
+            }
+            if (!additive) {
+              newSorted = newSorted.slice(_existingIndex, column.length);
+            }
+            // New Sort Column
+          } else if (additive) {
+            newSorted = newSorted.concat(column.map(function (d) {
+              return {
+                id: d.id,
+                desc: firstSortDirection
+              };
+            }));
+          } else {
+            newSorted = column.map(function (d) {
+              return {
+                id: d.id,
+                desc: firstSortDirection
+              };
+            });
+          }
+        }
+
+        this.setStateWithData({
+          page: !sorted.length && newSorted.length || !additive ? 0 : this.state.page,
+          sorted: newSorted
+        }, function () {
+          return onSortedChange && onSortedChange(newSorted, column, additive);
+        });
+      }
+    }, {
+      key: 'filterColumn',
+      value: function filterColumn(column, value) {
+        var _getResolvedState3 = this.getResolvedState(),
+            filtered = _getResolvedState3.filtered;
+
+        var onFilteredChange = this.props.onFilteredChange;
+
+        // Remove old filter first if it exists
+
+        var newFiltering = (filtered || []).filter(function (x) {
+          return x.id !== column.id;
+        });
+
+        if (value !== '') {
+          newFiltering.push({
+            id: column.id,
+            value: value
+          });
+        }
+
+        this.setStateWithData({
+          filtered: newFiltering
+        }, function () {
+          return onFilteredChange && onFilteredChange(newFiltering, column, value);
+        });
+      }
+    }, {
+      key: 'resizeColumnStart',
+      value: function resizeColumnStart(event, column, isTouch) {
+        var _this5 = this;
+
+        event.stopPropagation();
+        var parentWidth = event.target.parentElement.getBoundingClientRect().width;
+
+        var pageX = void 0;
+        if (isTouch) {
+          pageX = event.changedTouches[0].pageX;
+        } else {
+          pageX = event.pageX;
+        }
+
+        this.trapEvents = true;
+        this.setStateWithData({
+          currentlyResizing: {
+            id: column.id,
+            startX: pageX,
+            parentWidth: parentWidth
+          }
+        }, function () {
+          if (isTouch) {
+            document.addEventListener('touchmove', _this5.resizeColumnMoving);
+            document.addEventListener('touchcancel', _this5.resizeColumnEnd);
+            document.addEventListener('touchend', _this5.resizeColumnEnd);
+          } else {
+            document.addEventListener('mousemove', _this5.resizeColumnMoving);
+            document.addEventListener('mouseup', _this5.resizeColumnEnd);
+            document.addEventListener('mouseleave', _this5.resizeColumnEnd);
+          }
+        });
+      }
+    }, {
+      key: 'resizeColumnMoving',
+      value: function resizeColumnMoving(event) {
+        event.stopPropagation();
+        var _props2 = this.props,
+            onResizedChange = _props2.onResizedChange,
+            column = _props2.column;
+
+        var _getResolvedState4 = this.getResolvedState(),
+            resized = _getResolvedState4.resized,
+            currentlyResizing = _getResolvedState4.currentlyResizing,
+            columns = _getResolvedState4.columns;
+
+        var currentColumn = columns.find(function (c) {
+          return c.accessor === currentlyResizing.id || c.id === currentlyResizing.id;
+        });
+        var minResizeWidth = currentColumn && currentColumn.minResizeWidth != null ? currentColumn.minResizeWidth : column.minResizeWidth;
+
+        // Delete old value
+        var newResized = resized.filter(function (x) {
+          return x.id !== currentlyResizing.id;
+        });
+
+        var pageX = void 0;
+
+        if (event.type === 'touchmove') {
+          pageX = event.changedTouches[0].pageX;
+        } else if (event.type === 'mousemove') {
+          pageX = event.pageX;
+        }
+
+        var newWidth = Math.max(currentlyResizing.parentWidth + pageX - currentlyResizing.startX, minResizeWidth);
+
+        newResized.push({
+          id: currentlyResizing.id,
+          value: newWidth
+        });
+
+        this.setStateWithData({
+          resized: newResized
+        }, function () {
+          return onResizedChange && onResizedChange(newResized, event);
+        });
+      }
+    }, {
+      key: 'resizeColumnEnd',
+      value: function resizeColumnEnd(event) {
+        event.stopPropagation();
+        var isTouch = event.type === 'touchend' || event.type === 'touchcancel';
+
+        if (isTouch) {
+          document.removeEventListener('touchmove', this.resizeColumnMoving);
+          document.removeEventListener('touchcancel', this.resizeColumnEnd);
+          document.removeEventListener('touchend', this.resizeColumnEnd);
+        }
+
+        // If its a touch event clear the mouse one's as well because sometimes
+        // the mouseDown event gets called as well, but the mouseUp event doesn't
+        document.removeEventListener('mousemove', this.resizeColumnMoving);
+        document.removeEventListener('mouseup', this.resizeColumnEnd);
+        document.removeEventListener('mouseleave', this.resizeColumnEnd);
+
+        // The touch events don't propagate up to the sorting's onMouseDown event so
+        // no need to prevent it from happening or else the first click after a touch
+        // event resize will not sort the column.
+        if (!isTouch) {
+          this.setStateWithData({
+            skipNextSort: true,
+            currentlyResizing: false
+          });
+        }
+      }
+    }]);
+
+    return _class;
+  }(Base);
+});
+
+var _createClass$1 = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _extends$2 = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+function _classCallCheck$1(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn$1(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits$1(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var defaultButton = function defaultButton(props) {
+  return React__default["default"].createElement(
+    'button',
+    _extends$2({ type: 'button' }, props, { className: '-btn' }),
+    props.children
+  );
+};
+
+var ReactTablePagination = function (_Component) {
+  _inherits$1(ReactTablePagination, _Component);
+
+  function ReactTablePagination(props) {
+    _classCallCheck$1(this, ReactTablePagination);
+
+    var _this = _possibleConstructorReturn$1(this, (ReactTablePagination.__proto__ || Object.getPrototypeOf(ReactTablePagination)).call(this, props));
+
+    _this.getSafePage = _this.getSafePage.bind(_this);
+    _this.changePage = _this.changePage.bind(_this);
+    _this.applyPage = _this.applyPage.bind(_this);
+
+    _this.state = {
+      page: props.page
+    };
+    return _this;
+  }
+
+  _createClass$1(ReactTablePagination, [{
+    key: 'componentWillReceiveProps',
+    value: function componentWillReceiveProps(nextProps) {
+      if (this.props.page !== nextProps.page) {
+        this.setState({ page: nextProps.page });
+      }
+    }
+  }, {
+    key: 'getSafePage',
+    value: function getSafePage(page) {
+      if (Number.isNaN(page)) {
+        page = this.props.page;
+      }
+      return Math.min(Math.max(page, 0), this.props.pages - 1);
+    }
+  }, {
+    key: 'changePage',
+    value: function changePage(page) {
+      page = this.getSafePage(page);
+      this.setState({ page: page });
+      if (this.props.page !== page) {
+        this.props.onPageChange(page);
+      }
+    }
+  }, {
+    key: 'applyPage',
+    value: function applyPage(e) {
+      if (e) {
+        e.preventDefault();
+      }
+      var page = this.state.page;
+      this.changePage(page === '' ? this.props.page : page);
+    }
+  }, {
+    key: 'getPageJumpProperties',
+    value: function getPageJumpProperties() {
+      var _this2 = this;
+
+      return {
+        onKeyPress: function onKeyPress(e) {
+          if (e.which === 13 || e.keyCode === 13) {
+            _this2.applyPage();
+          }
+        },
+        onBlur: this.applyPage,
+        value: this.state.page === '' ? '' : this.state.page + 1,
+        onChange: function onChange(e) {
+          var val = e.target.value;
+          var page = val - 1;
+          if (val === '') {
+            return _this2.setState({ page: val });
+          }
+          _this2.setState({ page: _this2.getSafePage(page) });
+        },
+        inputType: this.state.page === '' ? 'text' : 'number',
+        pageJumpText: this.props.pageJumpText
+      };
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      var _this3 = this;
+
+      var _props = this.props,
+          pages = _props.pages,
+          page = _props.page,
+          showPageSizeOptions = _props.showPageSizeOptions,
+          pageSizeOptions = _props.pageSizeOptions,
+          pageSize = _props.pageSize,
+          showPageJump = _props.showPageJump,
+          canPrevious = _props.canPrevious,
+          canNext = _props.canNext,
+          onPageSizeChange = _props.onPageSizeChange,
+          className = _props.className,
+          PreviousComponent = _props.PreviousComponent,
+          NextComponent = _props.NextComponent,
+          renderPageJump = _props.renderPageJump,
+          renderCurrentPage = _props.renderCurrentPage,
+          renderTotalPagesCount = _props.renderTotalPagesCount,
+          renderPageSizeOptions = _props.renderPageSizeOptions;
+
+
+      return React__default["default"].createElement(
+        'div',
+        { className: classnames__default["default"](className, '-pagination'), style: this.props.style },
+        React__default["default"].createElement(
+          'div',
+          { className: '-previous' },
+          React__default["default"].createElement(
+            PreviousComponent,
+            {
+              onClick: function onClick() {
+                if (!canPrevious) return;
+                _this3.changePage(page - 1);
+              },
+              disabled: !canPrevious
+            },
+            this.props.previousText
+          )
+        ),
+        React__default["default"].createElement(
+          'div',
+          { className: '-center' },
+          React__default["default"].createElement(
+            'span',
+            { className: '-pageInfo' },
+            this.props.pageText,
+            ' ',
+            showPageJump ? renderPageJump(this.getPageJumpProperties()) : renderCurrentPage(page),
+            ' ',
+            this.props.ofText,
+            ' ',
+            renderTotalPagesCount(pages)
+          ),
+          showPageSizeOptions && renderPageSizeOptions({
+            pageSize: pageSize,
+            rowsSelectorText: this.props.rowsSelectorText,
+            pageSizeOptions: pageSizeOptions,
+            onPageSizeChange: onPageSizeChange,
+            rowsText: this.props.rowsText
+          })
+        ),
+        React__default["default"].createElement(
+          'div',
+          { className: '-next' },
+          React__default["default"].createElement(
+            NextComponent,
+            {
+              onClick: function onClick() {
+                if (!canNext) return;
+                _this3.changePage(page + 1);
+              },
+              disabled: !canNext
+            },
+            this.props.nextText
+          )
+        )
+      );
+    }
+  }]);
+
+  return ReactTablePagination;
+}(React.Component);
+
+ReactTablePagination.defaultProps = {
+  PreviousComponent: defaultButton,
+  NextComponent: defaultButton,
+  renderPageJump: function renderPageJump(_ref) {
+    var onChange = _ref.onChange,
+        value = _ref.value,
+        onBlur = _ref.onBlur,
+        onKeyPress = _ref.onKeyPress,
+        inputType = _ref.inputType,
+        pageJumpText = _ref.pageJumpText;
+    return React__default["default"].createElement(
+      'div',
+      { className: '-pageJump' },
+      React__default["default"].createElement('input', {
+        'aria-label': pageJumpText,
+        type: inputType,
+        onChange: onChange,
+        value: value,
+        onBlur: onBlur,
+        onKeyPress: onKeyPress
+      })
+    );
+  },
+  renderCurrentPage: function renderCurrentPage(page) {
+    return React__default["default"].createElement(
+      'span',
+      { className: '-currentPage' },
+      page + 1
+    );
+  },
+  renderTotalPagesCount: function renderTotalPagesCount(pages) {
+    return React__default["default"].createElement(
+      'span',
+      { className: '-totalPages' },
+      pages || 1
+    );
+  },
+  renderPageSizeOptions: function renderPageSizeOptions(_ref2) {
+    var pageSize = _ref2.pageSize,
+        pageSizeOptions = _ref2.pageSizeOptions,
+        rowsSelectorText = _ref2.rowsSelectorText,
+        onPageSizeChange = _ref2.onPageSizeChange,
+        rowsText = _ref2.rowsText;
+    return React__default["default"].createElement(
+      'span',
+      { className: 'select-wrap -pageSizeOptions' },
+      React__default["default"].createElement(
+        'select',
+        {
+          'aria-label': rowsSelectorText,
+          onChange: function onChange(e) {
+            return onPageSizeChange(Number(e.target.value));
+          },
+          value: pageSize
+        },
+        pageSizeOptions.map(function (option, i) {
+          return (
+            // eslint-disable-next-line react/no-array-index-key
+            React__default["default"].createElement(
+              'option',
+              { key: i, value: option },
+              option + ' ' + rowsText
+            )
+          );
+        })
+      )
+    );
+  }
+};
+
+var _extends$1 = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
+
+var emptyObj = function emptyObj() {
+  return {};
+};
+
+var defaultProps = {
+  // General
+  data: [],
+  resolveData: function resolveData(data) {
+    return data;
+  },
+  loading: false,
+  showPagination: true,
+  showPaginationTop: false,
+  showPaginationBottom: true,
+  showPageSizeOptions: true,
+  pageSizeOptions: [5, 10, 20, 25, 50, 100],
+  defaultPage: 0,
+  defaultPageSize: 20,
+  showPageJump: true,
+  collapseOnSortingChange: true,
+  collapseOnPageChange: true,
+  collapseOnDataChange: true,
+  freezeWhenExpanded: false,
+  sortable: true,
+  multiSort: true,
+  resizable: true,
+  filterable: false,
+  defaultSortDesc: false,
+  defaultSorted: [],
+  defaultFiltered: [],
+  defaultResized: [],
+  defaultExpanded: {},
+  // eslint-disable-next-line no-unused-vars
+  defaultFilterMethod: function defaultFilterMethod(filter, row, column) {
+    var id = filter.pivotId || filter.id;
+    return row[id] !== undefined ? String(row[id]).startsWith(filter.value) : true;
+  },
+  // eslint-disable-next-line no-unused-vars
+  defaultSortMethod: function defaultSortMethod(a, b, desc) {
+    // force null and undefined to the bottom
+    a = a === null || a === undefined ? '' : a;
+    b = b === null || b === undefined ? '' : b;
+    // force any string values to lowercase
+    a = typeof a === 'string' ? a.toLowerCase() : a;
+    b = typeof b === 'string' ? b.toLowerCase() : b;
+    // Return either 1 or -1 to indicate a sort priority
+    if (a > b) {
+      return 1;
+    }
+    if (a < b) {
+      return -1;
+    }
+    // returning 0, undefined or any falsey value will use subsequent sorts or
+    // the index as a tiebreaker
+    return 0;
+  },
+
+  // Controlled State Props
+  // page: undefined,
+  // pageSize: undefined,
+  // sorted: [],
+  // filtered: [],
+  // resized: [],
+  // expanded: {},
+
+  // Controlled State Callbacks
+  onPageChange: undefined,
+  onPageSizeChange: undefined,
+  onSortedChange: undefined,
+  onFilteredChange: undefined,
+  onResizedChange: undefined,
+  onExpandedChange: undefined,
+
+  // Pivoting
+  pivotBy: undefined,
+
+  // Key Constants
+  pivotValKey: '_pivotVal',
+  pivotIDKey: '_pivotID',
+  subRowsKey: '_subRows',
+  aggregatedKey: '_aggregated',
+  nestingLevelKey: '_nestingLevel',
+  originalKey: '_original',
+  indexKey: '_index',
+  groupedByPivotKey: '_groupedByPivot',
+
+  // Server-side Callbacks
+  onFetchData: function onFetchData() {
+    return null;
+  },
+
+  // Classes
+  className: '',
+  style: {},
+
+  // Component decorators
+  getProps: emptyObj,
+  getTableProps: emptyObj,
+  getTheadGroupProps: emptyObj,
+  getTheadGroupTrProps: emptyObj,
+  getTheadGroupThProps: emptyObj,
+  getTheadProps: emptyObj,
+  getTheadTrProps: emptyObj,
+  getTheadThProps: emptyObj,
+  getTheadFilterProps: emptyObj,
+  getTheadFilterTrProps: emptyObj,
+  getTheadFilterThProps: emptyObj,
+  getTbodyProps: emptyObj,
+  getTrGroupProps: emptyObj,
+  getTrProps: emptyObj,
+  getTdProps: emptyObj,
+  getTfootProps: emptyObj,
+  getTfootTrProps: emptyObj,
+  getTfootTdProps: emptyObj,
+  getPaginationProps: emptyObj,
+  getLoadingProps: emptyObj,
+  getNoDataProps: emptyObj,
+  getResizerProps: emptyObj,
+
+  // Global Column Defaults
+  column: {
+    // Renderers
+    Cell: undefined,
+    Header: undefined,
+    Footer: undefined,
+    Aggregated: undefined,
+    Pivot: undefined,
+    PivotValue: undefined,
+    Expander: undefined,
+    Filter: undefined,
+    Placeholder: undefined,
+    // All Columns
+    sortable: undefined, // use table default
+    resizable: undefined, // use table default
+    filterable: undefined, // use table default
+    show: true,
+    minWidth: 100,
+    minResizeWidth: 11,
+    // Cells only
+    className: '',
+    style: {},
+    getProps: emptyObj,
+    // Pivot only
+    aggregate: undefined,
+    // Headers only
+    headerClassName: '',
+    headerStyle: {},
+    getHeaderProps: emptyObj,
+    // Footers only
+    footerClassName: '',
+    footerStyle: {},
+    getFooterProps: emptyObj,
+    filterMethod: undefined,
+    filterAll: false,
+    sortMethod: undefined
+  },
+
+  // Global Expander Column Defaults
+  expanderDefaults: {
+    sortable: false,
+    resizable: false,
+    filterable: false,
+    width: 35
+  },
+
+  pivotDefaults: {
+    // extend the defaults for pivoted columns here
+  },
+
+  // Text
+  previousText: 'Previous',
+  nextText: 'Next',
+  loadingText: 'Loading...',
+  noDataText: 'No rows found',
+  pageText: 'Page',
+  ofText: 'of',
+  rowsText: 'rows',
+  pageJumpText: 'jump to page',
+  rowsSelectorText: 'rows per page',
+
+  // Components
+  TableComponent: function TableComponent(_ref) {
+    var children = _ref.children,
+        className = _ref.className,
+        rest = _objectWithoutProperties(_ref, ['children', 'className']);
+
+    return React__default["default"].createElement(
+      'div',
+      _extends$1({
+        className: classnames__default["default"]('rt-table', className),
+        role: 'grid'
+        // tabIndex='0'
+      }, rest),
+      children
+    );
+  },
+  TheadComponent: _.makeTemplateComponent('rt-thead', 'Thead'),
+  TbodyComponent: _.makeTemplateComponent('rt-tbody', 'Tbody'),
+  TrGroupComponent: function TrGroupComponent(_ref2) {
+    var children = _ref2.children,
+        className = _ref2.className,
+        rest = _objectWithoutProperties(_ref2, ['children', 'className']);
+
+    return React__default["default"].createElement(
+      'div',
+      _extends$1({ className: classnames__default["default"]('rt-tr-group', className), role: 'rowgroup' }, rest),
+      children
+    );
+  },
+  TrComponent: function TrComponent(_ref3) {
+    var children = _ref3.children,
+        className = _ref3.className,
+        rest = _objectWithoutProperties(_ref3, ['children', 'className']);
+
+    return React__default["default"].createElement(
+      'div',
+      _extends$1({ className: classnames__default["default"]('rt-tr', className), role: 'row' }, rest),
+      children
+    );
+  },
+  ThComponent: function ThComponent(_ref4) {
+    var toggleSort = _ref4.toggleSort,
+        className = _ref4.className,
+        children = _ref4.children,
+        rest = _objectWithoutProperties(_ref4, ['toggleSort', 'className', 'children']);
+
+    return (
+      // eslint-disable-next-line jsx-a11y/click-events-have-key-events
+      React__default["default"].createElement(
+        'div',
+        _extends$1({
+          className: classnames__default["default"]('rt-th', className),
+          onClick: function onClick(e) {
+            return toggleSort && toggleSort(e);
+          },
+          role: 'columnheader',
+          tabIndex: '-1' // Resolves eslint issues without implementing keyboard navigation incorrectly
+        }, rest),
+        children
+      )
+    );
+  },
+  TdComponent: function TdComponent(_ref5) {
+    _ref5.toggleSort;
+        var className = _ref5.className,
+        children = _ref5.children,
+        rest = _objectWithoutProperties(_ref5, ['toggleSort', 'className', 'children']);
+
+    return React__default["default"].createElement(
+      'div',
+      _extends$1({ className: classnames__default["default"]('rt-td', className), role: 'gridcell' }, rest),
+      children
+    );
+  },
+  TfootComponent: _.makeTemplateComponent('rt-tfoot', 'Tfoot'),
+  FilterComponent: function FilterComponent(_ref6) {
+    var filter = _ref6.filter,
+        _onChange = _ref6.onChange,
+        column = _ref6.column;
+    return React__default["default"].createElement('input', {
+      type: 'text',
+      style: {
+        width: '100%'
+      },
+      placeholder: column.Placeholder,
+      value: filter ? filter.value : '',
+      onChange: function onChange(event) {
+        return _onChange(event.target.value);
+      }
+    });
+  },
+  ExpanderComponent: function ExpanderComponent(_ref7) {
+    var isExpanded = _ref7.isExpanded;
+    return React__default["default"].createElement(
+      'div',
+      { className: classnames__default["default"]('rt-expander', isExpanded && '-open') },
+      '\u2022'
+    );
+  },
+  PivotValueComponent: function PivotValueComponent(_ref8) {
+    var subRows = _ref8.subRows,
+        value = _ref8.value;
+    return React__default["default"].createElement(
+      'span',
+      null,
+      value,
+      ' ',
+      subRows && '(' + subRows.length + ')'
+    );
+  },
+  AggregatedComponent: function AggregatedComponent(_ref9) {
+    var subRows = _ref9.subRows,
+        column = _ref9.column;
+
+    var previewValues = subRows.filter(function (d) {
+      return typeof d[column.id] !== 'undefined';
+    }).map(function (row, i) {
+      return (
+        // eslint-disable-next-line react/no-array-index-key
+        React__default["default"].createElement(
+          'span',
+          { key: i },
+          row[column.id],
+          i < subRows.length - 1 ? ', ' : ''
+        )
+      );
+    });
+    return React__default["default"].createElement(
+      'span',
+      null,
+      previewValues
+    );
+  },
+  PivotComponent: undefined, // this is a computed default generated using
+  // the ExpanderComponent and PivotValueComponent at run-time in methods.js
+  PaginationComponent: ReactTablePagination,
+  PreviousComponent: undefined,
+  NextComponent: undefined,
+  LoadingComponent: function LoadingComponent(_ref10) {
+    var className = _ref10.className,
+        loading = _ref10.loading,
+        loadingText = _ref10.loadingText,
+        rest = _objectWithoutProperties(_ref10, ['className', 'loading', 'loadingText']);
+
+    return React__default["default"].createElement(
+      'div',
+      _extends$1({ className: classnames__default["default"]('-loading', { '-active': loading }, className) }, rest),
+      React__default["default"].createElement(
+        'div',
+        { className: '-loading-inner' },
+        loadingText
+      )
+    );
+  },
+  NoDataComponent: _.makeTemplateComponent('rt-noData', 'NoData'),
+  ResizerComponent: _.makeTemplateComponent('rt-resizer', 'Resizer'),
+  PadRowComponent: function PadRowComponent() {
+    return React__default["default"].createElement(
+      'span',
+      null,
+      '\xA0'
+    );
+  }
+};
+
+var propTypes$1 = {exports: {}};
+
+var reactIs = {exports: {}};
+
+var reactIs_production_min = {};
+
+/** @license React v16.8.6
+ * react-is.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredReactIs_production_min;
+
+function requireReactIs_production_min () {
+	if (hasRequiredReactIs_production_min) return reactIs_production_min;
+	hasRequiredReactIs_production_min = 1;
+Object.defineProperty(reactIs_production_min,"__esModule",{value:!0});
+	var b="function"===typeof Symbol&&Symbol.for,c=b?Symbol.for("react.element"):60103,d=b?Symbol.for("react.portal"):60106,e=b?Symbol.for("react.fragment"):60107,f=b?Symbol.for("react.strict_mode"):60108,g=b?Symbol.for("react.profiler"):60114,h=b?Symbol.for("react.provider"):60109,k=b?Symbol.for("react.context"):60110,l=b?Symbol.for("react.async_mode"):60111,m=b?Symbol.for("react.concurrent_mode"):60111,n=b?Symbol.for("react.forward_ref"):60112,p=b?Symbol.for("react.suspense"):60113,q=b?Symbol.for("react.memo"):
+	60115,r=b?Symbol.for("react.lazy"):60116;function t(a){if("object"===typeof a&&null!==a){var u=a.$$typeof;switch(u){case c:switch(a=a.type,a){case l:case m:case e:case g:case f:case p:return a;default:switch(a=a&&a.$$typeof,a){case k:case n:case h:return a;default:return u}}case r:case q:case d:return u}}}function v(a){return t(a)===m}reactIs_production_min.typeOf=t;reactIs_production_min.AsyncMode=l;reactIs_production_min.ConcurrentMode=m;reactIs_production_min.ContextConsumer=k;reactIs_production_min.ContextProvider=h;reactIs_production_min.Element=c;reactIs_production_min.ForwardRef=n;
+	reactIs_production_min.Fragment=e;reactIs_production_min.Lazy=r;reactIs_production_min.Memo=q;reactIs_production_min.Portal=d;reactIs_production_min.Profiler=g;reactIs_production_min.StrictMode=f;reactIs_production_min.Suspense=p;reactIs_production_min.isValidElementType=function(a){return "string"===typeof a||"function"===typeof a||a===e||a===m||a===g||a===f||a===p||"object"===typeof a&&null!==a&&(a.$$typeof===r||a.$$typeof===q||a.$$typeof===h||a.$$typeof===k||a.$$typeof===n)};reactIs_production_min.isAsyncMode=function(a){return v(a)||t(a)===l};reactIs_production_min.isConcurrentMode=v;reactIs_production_min.isContextConsumer=function(a){return t(a)===k};
+	reactIs_production_min.isContextProvider=function(a){return t(a)===h};reactIs_production_min.isElement=function(a){return "object"===typeof a&&null!==a&&a.$$typeof===c};reactIs_production_min.isForwardRef=function(a){return t(a)===n};reactIs_production_min.isFragment=function(a){return t(a)===e};reactIs_production_min.isLazy=function(a){return t(a)===r};reactIs_production_min.isMemo=function(a){return t(a)===q};reactIs_production_min.isPortal=function(a){return t(a)===d};reactIs_production_min.isProfiler=function(a){return t(a)===g};reactIs_production_min.isStrictMode=function(a){return t(a)===f};
+	reactIs_production_min.isSuspense=function(a){return t(a)===p};
+	return reactIs_production_min;
+}
+
+var reactIs_development = {};
+
+/** @license React v16.8.6
+ * react-is.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredReactIs_development;
+
+function requireReactIs_development () {
+	if (hasRequiredReactIs_development) return reactIs_development;
+	hasRequiredReactIs_development = 1;
+	(function (exports) {
+
+
+
+		if (process.env.NODE_ENV !== "production") {
+		  (function() {
+
+		Object.defineProperty(exports, '__esModule', { value: true });
+
+		// The Symbol used to tag the ReactElement-like types. If there is no native Symbol
+		// nor polyfill, then a plain number is used for performance.
+		var hasSymbol = typeof Symbol === 'function' && Symbol.for;
+
+		var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;
+		var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;
+		var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;
+		var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;
+		var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;
+		var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;
+		var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace;
+		var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf;
+		var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;
+		var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;
+		var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;
+		var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;
+		var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;
+
+		function isValidElementType(type) {
+		  return typeof type === 'string' || typeof type === 'function' ||
+		  // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
+		  type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE);
+		}
+
+		/**
+		 * Forked from fbjs/warning:
+		 * https://github.com/facebook/fbjs/blob/e66ba20ad5be433eb54423f2b097d829324d9de6/packages/fbjs/src/__forks__/warning.js
+		 *
+		 * Only change is we use console.warn instead of console.error,
+		 * and do nothing when 'console' is not supported.
+		 * This really simplifies the code.
+		 * ---
+		 * Similar to invariant but only logs a warning if the condition is not met.
+		 * This can be used to log issues in development environments in critical
+		 * paths. Removing the logging code for production environments will keep the
+		 * same logic and follow the same code paths.
+		 */
+
+		var lowPriorityWarning = function () {};
+
+		{
+		  var printWarning = function (format) {
+		    for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+		      args[_key - 1] = arguments[_key];
+		    }
+
+		    var argIndex = 0;
+		    var message = 'Warning: ' + format.replace(/%s/g, function () {
+		      return args[argIndex++];
+		    });
+		    if (typeof console !== 'undefined') {
+		      console.warn(message);
+		    }
+		    try {
+		      // --- Welcome to debugging React ---
+		      // This error was thrown as a convenience so that you can use this stack
+		      // to find the callsite that caused this warning to fire.
+		      throw new Error(message);
+		    } catch (x) {}
+		  };
+
+		  lowPriorityWarning = function (condition, format) {
+		    if (format === undefined) {
+		      throw new Error('`lowPriorityWarning(condition, format, ...args)` requires a warning ' + 'message argument');
+		    }
+		    if (!condition) {
+		      for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+		        args[_key2 - 2] = arguments[_key2];
+		      }
+
+		      printWarning.apply(undefined, [format].concat(args));
+		    }
+		  };
+		}
+
+		var lowPriorityWarning$1 = lowPriorityWarning;
+
+		function typeOf(object) {
+		  if (typeof object === 'object' && object !== null) {
+		    var $$typeof = object.$$typeof;
+		    switch ($$typeof) {
+		      case REACT_ELEMENT_TYPE:
+		        var type = object.type;
+
+		        switch (type) {
+		          case REACT_ASYNC_MODE_TYPE:
+		          case REACT_CONCURRENT_MODE_TYPE:
+		          case REACT_FRAGMENT_TYPE:
+		          case REACT_PROFILER_TYPE:
+		          case REACT_STRICT_MODE_TYPE:
+		          case REACT_SUSPENSE_TYPE:
+		            return type;
+		          default:
+		            var $$typeofType = type && type.$$typeof;
+
+		            switch ($$typeofType) {
+		              case REACT_CONTEXT_TYPE:
+		              case REACT_FORWARD_REF_TYPE:
+		              case REACT_PROVIDER_TYPE:
+		                return $$typeofType;
+		              default:
+		                return $$typeof;
+		            }
+		        }
+		      case REACT_LAZY_TYPE:
+		      case REACT_MEMO_TYPE:
+		      case REACT_PORTAL_TYPE:
+		        return $$typeof;
+		    }
+		  }
+
+		  return undefined;
+		}
+
+		// AsyncMode is deprecated along with isAsyncMode
+		var AsyncMode = REACT_ASYNC_MODE_TYPE;
+		var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
+		var ContextConsumer = REACT_CONTEXT_TYPE;
+		var ContextProvider = REACT_PROVIDER_TYPE;
+		var Element = REACT_ELEMENT_TYPE;
+		var ForwardRef = REACT_FORWARD_REF_TYPE;
+		var Fragment = REACT_FRAGMENT_TYPE;
+		var Lazy = REACT_LAZY_TYPE;
+		var Memo = REACT_MEMO_TYPE;
+		var Portal = REACT_PORTAL_TYPE;
+		var Profiler = REACT_PROFILER_TYPE;
+		var StrictMode = REACT_STRICT_MODE_TYPE;
+		var Suspense = REACT_SUSPENSE_TYPE;
+
+		var hasWarnedAboutDeprecatedIsAsyncMode = false;
+
+		// AsyncMode should be deprecated
+		function isAsyncMode(object) {
+		  {
+		    if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+		      hasWarnedAboutDeprecatedIsAsyncMode = true;
+		      lowPriorityWarning$1(false, 'The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.');
+		    }
+		  }
+		  return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
+		}
+		function isConcurrentMode(object) {
+		  return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
+		}
+		function isContextConsumer(object) {
+		  return typeOf(object) === REACT_CONTEXT_TYPE;
+		}
+		function isContextProvider(object) {
+		  return typeOf(object) === REACT_PROVIDER_TYPE;
+		}
+		function isElement(object) {
+		  return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+		}
+		function isForwardRef(object) {
+		  return typeOf(object) === REACT_FORWARD_REF_TYPE;
+		}
+		function isFragment(object) {
+		  return typeOf(object) === REACT_FRAGMENT_TYPE;
+		}
+		function isLazy(object) {
+		  return typeOf(object) === REACT_LAZY_TYPE;
+		}
+		function isMemo(object) {
+		  return typeOf(object) === REACT_MEMO_TYPE;
+		}
+		function isPortal(object) {
+		  return typeOf(object) === REACT_PORTAL_TYPE;
+		}
+		function isProfiler(object) {
+		  return typeOf(object) === REACT_PROFILER_TYPE;
+		}
+		function isStrictMode(object) {
+		  return typeOf(object) === REACT_STRICT_MODE_TYPE;
+		}
+		function isSuspense(object) {
+		  return typeOf(object) === REACT_SUSPENSE_TYPE;
+		}
+
+		exports.typeOf = typeOf;
+		exports.AsyncMode = AsyncMode;
+		exports.ConcurrentMode = ConcurrentMode;
+		exports.ContextConsumer = ContextConsumer;
+		exports.ContextProvider = ContextProvider;
+		exports.Element = Element;
+		exports.ForwardRef = ForwardRef;
+		exports.Fragment = Fragment;
+		exports.Lazy = Lazy;
+		exports.Memo = Memo;
+		exports.Portal = Portal;
+		exports.Profiler = Profiler;
+		exports.StrictMode = StrictMode;
+		exports.Suspense = Suspense;
+		exports.isValidElementType = isValidElementType;
+		exports.isAsyncMode = isAsyncMode;
+		exports.isConcurrentMode = isConcurrentMode;
+		exports.isContextConsumer = isContextConsumer;
+		exports.isContextProvider = isContextProvider;
+		exports.isElement = isElement;
+		exports.isForwardRef = isForwardRef;
+		exports.isFragment = isFragment;
+		exports.isLazy = isLazy;
+		exports.isMemo = isMemo;
+		exports.isPortal = isPortal;
+		exports.isProfiler = isProfiler;
+		exports.isStrictMode = isStrictMode;
+		exports.isSuspense = isSuspense;
+		  })();
+		}
+} (reactIs_development));
+	return reactIs_development;
+}
+
+var hasRequiredReactIs;
+
+function requireReactIs () {
+	if (hasRequiredReactIs) return reactIs.exports;
+	hasRequiredReactIs = 1;
+	(function (module) {
+
+		if (process.env.NODE_ENV === 'production') {
+		  module.exports = requireReactIs_production_min();
+		} else {
+		  module.exports = requireReactIs_development();
+		}
+} (reactIs));
+	return reactIs.exports;
+}
+
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+
+var objectAssign;
+var hasRequiredObjectAssign;
+
+function requireObjectAssign () {
+	if (hasRequiredObjectAssign) return objectAssign;
+	hasRequiredObjectAssign = 1;
+	/* eslint-disable no-unused-vars */
+	var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+	var hasOwnProperty = Object.prototype.hasOwnProperty;
+	var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+
+	function toObject(val) {
+		if (val === null || val === undefined) {
+			throw new TypeError('Object.assign cannot be called with null or undefined');
+		}
+
+		return Object(val);
+	}
+
+	function shouldUseNative() {
+		try {
+			if (!Object.assign) {
+				return false;
+			}
+
+			// Detect buggy property enumeration order in older V8 versions.
+
+			// https://bugs.chromium.org/p/v8/issues/detail?id=4118
+			var test1 = new String('abc');  // eslint-disable-line no-new-wrappers
+			test1[5] = 'de';
+			if (Object.getOwnPropertyNames(test1)[0] === '5') {
+				return false;
+			}
+
+			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+			var test2 = {};
+			for (var i = 0; i < 10; i++) {
+				test2['_' + String.fromCharCode(i)] = i;
+			}
+			var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
+				return test2[n];
+			});
+			if (order2.join('') !== '0123456789') {
+				return false;
+			}
+
+			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+			var test3 = {};
+			'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
+				test3[letter] = letter;
+			});
+			if (Object.keys(Object.assign({}, test3)).join('') !==
+					'abcdefghijklmnopqrst') {
+				return false;
+			}
+
+			return true;
+		} catch (err) {
+			// We don't expect any of the above to throw, but better to be safe.
+			return false;
+		}
+	}
+
+	objectAssign = shouldUseNative() ? Object.assign : function (target, source) {
+		var from;
+		var to = toObject(target);
+		var symbols;
+
+		for (var s = 1; s < arguments.length; s++) {
+			from = Object(arguments[s]);
+
+			for (var key in from) {
+				if (hasOwnProperty.call(from, key)) {
+					to[key] = from[key];
+				}
+			}
+
+			if (getOwnPropertySymbols) {
+				symbols = getOwnPropertySymbols(from);
+				for (var i = 0; i < symbols.length; i++) {
+					if (propIsEnumerable.call(from, symbols[i])) {
+						to[symbols[i]] = from[symbols[i]];
+					}
+				}
+			}
+		}
+
+		return to;
+	};
+	return objectAssign;
+}
+
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var ReactPropTypesSecret_1;
+var hasRequiredReactPropTypesSecret;
+
+function requireReactPropTypesSecret () {
+	if (hasRequiredReactPropTypesSecret) return ReactPropTypesSecret_1;
+	hasRequiredReactPropTypesSecret = 1;
+
+	var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
+
+	ReactPropTypesSecret_1 = ReactPropTypesSecret;
+	return ReactPropTypesSecret_1;
+}
+
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var checkPropTypes_1;
+var hasRequiredCheckPropTypes;
+
+function requireCheckPropTypes () {
+	if (hasRequiredCheckPropTypes) return checkPropTypes_1;
+	hasRequiredCheckPropTypes = 1;
+
+	var printWarning = function() {};
+
+	if (process.env.NODE_ENV !== 'production') {
+	  var ReactPropTypesSecret = requireReactPropTypesSecret();
+	  var loggedTypeFailures = {};
+	  var has = Function.call.bind(Object.prototype.hasOwnProperty);
+
+	  printWarning = function(text) {
+	    var message = 'Warning: ' + text;
+	    if (typeof console !== 'undefined') {
+	      console.error(message);
+	    }
+	    try {
+	      // --- Welcome to debugging React ---
+	      // This error was thrown as a convenience so that you can use this stack
+	      // to find the callsite that caused this warning to fire.
+	      throw new Error(message);
+	    } catch (x) {}
+	  };
+	}
+
+	/**
+	 * Assert that the values match with the type specs.
+	 * Error messages are memorized and will only be shown once.
+	 *
+	 * @param {object} typeSpecs Map of name to a ReactPropType
+	 * @param {object} values Runtime values that need to be type-checked
+	 * @param {string} location e.g. "prop", "context", "child context"
+	 * @param {string} componentName Name of the component for error messages.
+	 * @param {?Function} getStack Returns the component stack.
+	 * @private
+	 */
+	function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
+	  if (process.env.NODE_ENV !== 'production') {
+	    for (var typeSpecName in typeSpecs) {
+	      if (has(typeSpecs, typeSpecName)) {
+	        var error;
+	        // Prop type validation may throw. In case they do, we don't want to
+	        // fail the render phase where it didn't fail before. So we log it.
+	        // After these have been cleaned up, we'll let them throw.
+	        try {
+	          // This is intentionally an invariant that gets caught. It's the same
+	          // behavior as without this statement except with a better message.
+	          if (typeof typeSpecs[typeSpecName] !== 'function') {
+	            var err = Error(
+	              (componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' +
+	              'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.'
+	            );
+	            err.name = 'Invariant Violation';
+	            throw err;
+	          }
+	          error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
+	        } catch (ex) {
+	          error = ex;
+	        }
+	        if (error && !(error instanceof Error)) {
+	          printWarning(
+	            (componentName || 'React class') + ': type specification of ' +
+	            location + ' `' + typeSpecName + '` is invalid; the type checker ' +
+	            'function must return `null` or an `Error` but returned a ' + typeof error + '. ' +
+	            'You may have forgotten to pass an argument to the type checker ' +
+	            'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' +
+	            'shape all require an argument).'
+	          );
+	        }
+	        if (error instanceof Error && !(error.message in loggedTypeFailures)) {
+	          // Only monitor this failure once because there tends to be a lot of the
+	          // same error.
+	          loggedTypeFailures[error.message] = true;
+
+	          var stack = getStack ? getStack() : '';
+
+	          printWarning(
+	            'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '')
+	          );
+	        }
+	      }
+	    }
+	  }
+	}
+
+	/**
+	 * Resets warning cache when testing.
+	 *
+	 * @private
+	 */
+	checkPropTypes.resetWarningCache = function() {
+	  if (process.env.NODE_ENV !== 'production') {
+	    loggedTypeFailures = {};
+	  }
+	};
+
+	checkPropTypes_1 = checkPropTypes;
+	return checkPropTypes_1;
+}
+
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var factoryWithTypeCheckers;
+var hasRequiredFactoryWithTypeCheckers;
+
+function requireFactoryWithTypeCheckers () {
+	if (hasRequiredFactoryWithTypeCheckers) return factoryWithTypeCheckers;
+	hasRequiredFactoryWithTypeCheckers = 1;
+
+	var ReactIs = requireReactIs();
+	var assign = requireObjectAssign();
+
+	var ReactPropTypesSecret = requireReactPropTypesSecret();
+	var checkPropTypes = requireCheckPropTypes();
+
+	var has = Function.call.bind(Object.prototype.hasOwnProperty);
+	var printWarning = function() {};
+
+	if (process.env.NODE_ENV !== 'production') {
+	  printWarning = function(text) {
+	    var message = 'Warning: ' + text;
+	    if (typeof console !== 'undefined') {
+	      console.error(message);
+	    }
+	    try {
+	      // --- Welcome to debugging React ---
+	      // This error was thrown as a convenience so that you can use this stack
+	      // to find the callsite that caused this warning to fire.
+	      throw new Error(message);
+	    } catch (x) {}
+	  };
+	}
+
+	function emptyFunctionThatReturnsNull() {
+	  return null;
+	}
+
+	factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {
+	  /* global Symbol */
+	  var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
+	  var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.
+
+	  /**
+	   * Returns the iterator method function contained on the iterable object.
+	   *
+	   * Be sure to invoke the function with the iterable as context:
+	   *
+	   *     var iteratorFn = getIteratorFn(myIterable);
+	   *     if (iteratorFn) {
+	   *       var iterator = iteratorFn.call(myIterable);
+	   *       ...
+	   *     }
+	   *
+	   * @param {?object} maybeIterable
+	   * @return {?function}
+	   */
+	  function getIteratorFn(maybeIterable) {
+	    var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
+	    if (typeof iteratorFn === 'function') {
+	      return iteratorFn;
+	    }
+	  }
+
+	  /**
+	   * Collection of methods that allow declaration and validation of props that are
+	   * supplied to React components. Example usage:
+	   *
+	   *   var Props = require('ReactPropTypes');
+	   *   var MyArticle = React.createClass({
+	   *     propTypes: {
+	   *       // An optional string prop named "description".
+	   *       description: Props.string,
+	   *
+	   *       // A required enum prop named "category".
+	   *       category: Props.oneOf(['News','Photos']).isRequired,
+	   *
+	   *       // A prop named "dialog" that requires an instance of Dialog.
+	   *       dialog: Props.instanceOf(Dialog).isRequired
+	   *     },
+	   *     render: function() { ... }
+	   *   });
+	   *
+	   * A more formal specification of how these methods are used:
+	   *
+	   *   type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)
+	   *   decl := ReactPropTypes.{type}(.isRequired)?
+	   *
+	   * Each and every declaration produces a function with the same signature. This
+	   * allows the creation of custom validation functions. For example:
+	   *
+	   *  var MyLink = React.createClass({
+	   *    propTypes: {
+	   *      // An optional string or URI prop named "href".
+	   *      href: function(props, propName, componentName) {
+	   *        var propValue = props[propName];
+	   *        if (propValue != null && typeof propValue !== 'string' &&
+	   *            !(propValue instanceof URI)) {
+	   *          return new Error(
+	   *            'Expected a string or an URI for ' + propName + ' in ' +
+	   *            componentName
+	   *          );
+	   *        }
+	   *      }
+	   *    },
+	   *    render: function() {...}
+	   *  });
+	   *
+	   * @internal
+	   */
+
+	  var ANONYMOUS = '<<anonymous>>';
+
+	  // Important!
+	  // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.
+	  var ReactPropTypes = {
+	    array: createPrimitiveTypeChecker('array'),
+	    bool: createPrimitiveTypeChecker('boolean'),
+	    func: createPrimitiveTypeChecker('function'),
+	    number: createPrimitiveTypeChecker('number'),
+	    object: createPrimitiveTypeChecker('object'),
+	    string: createPrimitiveTypeChecker('string'),
+	    symbol: createPrimitiveTypeChecker('symbol'),
+
+	    any: createAnyTypeChecker(),
+	    arrayOf: createArrayOfTypeChecker,
+	    element: createElementTypeChecker(),
+	    elementType: createElementTypeTypeChecker(),
+	    instanceOf: createInstanceTypeChecker,
+	    node: createNodeChecker(),
+	    objectOf: createObjectOfTypeChecker,
+	    oneOf: createEnumTypeChecker,
+	    oneOfType: createUnionTypeChecker,
+	    shape: createShapeTypeChecker,
+	    exact: createStrictShapeTypeChecker,
+	  };
+
+	  /**
+	   * inlined Object.is polyfill to avoid requiring consumers ship their own
+	   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+	   */
+	  /*eslint-disable no-self-compare*/
+	  function is(x, y) {
+	    // SameValue algorithm
+	    if (x === y) {
+	      // Steps 1-5, 7-10
+	      // Steps 6.b-6.e: +0 != -0
+	      return x !== 0 || 1 / x === 1 / y;
+	    } else {
+	      // Step 6.a: NaN == NaN
+	      return x !== x && y !== y;
+	    }
+	  }
+	  /*eslint-enable no-self-compare*/
+
+	  /**
+	   * We use an Error-like object for backward compatibility as people may call
+	   * PropTypes directly and inspect their output. However, we don't use real
+	   * Errors anymore. We don't inspect their stack anyway, and creating them
+	   * is prohibitively expensive if they are created too often, such as what
+	   * happens in oneOfType() for any type before the one that matched.
+	   */
+	  function PropTypeError(message) {
+	    this.message = message;
+	    this.stack = '';
+	  }
+	  // Make `instanceof Error` still work for returned errors.
+	  PropTypeError.prototype = Error.prototype;
+
+	  function createChainableTypeChecker(validate) {
+	    if (process.env.NODE_ENV !== 'production') {
+	      var manualPropTypeCallCache = {};
+	      var manualPropTypeWarningCount = 0;
+	    }
+	    function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
+	      componentName = componentName || ANONYMOUS;
+	      propFullName = propFullName || propName;
+
+	      if (secret !== ReactPropTypesSecret) {
+	        if (throwOnDirectAccess) {
+	          // New behavior only for users of `prop-types` package
+	          var err = new Error(
+	            'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
+	            'Use `PropTypes.checkPropTypes()` to call them. ' +
+	            'Read more at http://fb.me/use-check-prop-types'
+	          );
+	          err.name = 'Invariant Violation';
+	          throw err;
+	        } else if (process.env.NODE_ENV !== 'production' && typeof console !== 'undefined') {
+	          // Old behavior for people using React.PropTypes
+	          var cacheKey = componentName + ':' + propName;
+	          if (
+	            !manualPropTypeCallCache[cacheKey] &&
+	            // Avoid spamming the console because they are often not actionable except for lib authors
+	            manualPropTypeWarningCount < 3
+	          ) {
+	            printWarning(
+	              'You are manually calling a React.PropTypes validation ' +
+	              'function for the `' + propFullName + '` prop on `' + componentName  + '`. This is deprecated ' +
+	              'and will throw in the standalone `prop-types` package. ' +
+	              'You may be seeing this warning due to a third-party PropTypes ' +
+	              'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.'
+	            );
+	            manualPropTypeCallCache[cacheKey] = true;
+	            manualPropTypeWarningCount++;
+	          }
+	        }
+	      }
+	      if (props[propName] == null) {
+	        if (isRequired) {
+	          if (props[propName] === null) {
+	            return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));
+	          }
+	          return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));
+	        }
+	        return null;
+	      } else {
+	        return validate(props, propName, componentName, location, propFullName);
+	      }
+	    }
+
+	    var chainedCheckType = checkType.bind(null, false);
+	    chainedCheckType.isRequired = checkType.bind(null, true);
+
+	    return chainedCheckType;
+	  }
+
+	  function createPrimitiveTypeChecker(expectedType) {
+	    function validate(props, propName, componentName, location, propFullName, secret) {
+	      var propValue = props[propName];
+	      var propType = getPropType(propValue);
+	      if (propType !== expectedType) {
+	        // `propValue` being instance of, say, date/regexp, pass the 'object'
+	        // check, but we can offer a more precise error message here rather than
+	        // 'of type `object`'.
+	        var preciseType = getPreciseType(propValue);
+
+	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'));
+	      }
+	      return null;
+	    }
+	    return createChainableTypeChecker(validate);
+	  }
+
+	  function createAnyTypeChecker() {
+	    return createChainableTypeChecker(emptyFunctionThatReturnsNull);
+	  }
+
+	  function createArrayOfTypeChecker(typeChecker) {
+	    function validate(props, propName, componentName, location, propFullName) {
+	      if (typeof typeChecker !== 'function') {
+	        return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');
+	      }
+	      var propValue = props[propName];
+	      if (!Array.isArray(propValue)) {
+	        var propType = getPropType(propValue);
+	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));
+	      }
+	      for (var i = 0; i < propValue.length; i++) {
+	        var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);
+	        if (error instanceof Error) {
+	          return error;
+	        }
+	      }
+	      return null;
+	    }
+	    return createChainableTypeChecker(validate);
+	  }
+
+	  function createElementTypeChecker() {
+	    function validate(props, propName, componentName, location, propFullName) {
+	      var propValue = props[propName];
+	      if (!isValidElement(propValue)) {
+	        var propType = getPropType(propValue);
+	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));
+	      }
+	      return null;
+	    }
+	    return createChainableTypeChecker(validate);
+	  }
+
+	  function createElementTypeTypeChecker() {
+	    function validate(props, propName, componentName, location, propFullName) {
+	      var propValue = props[propName];
+	      if (!ReactIs.isValidElementType(propValue)) {
+	        var propType = getPropType(propValue);
+	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement type.'));
+	      }
+	      return null;
+	    }
+	    return createChainableTypeChecker(validate);
+	  }
+
+	  function createInstanceTypeChecker(expectedClass) {
+	    function validate(props, propName, componentName, location, propFullName) {
+	      if (!(props[propName] instanceof expectedClass)) {
+	        var expectedClassName = expectedClass.name || ANONYMOUS;
+	        var actualClassName = getClassName(props[propName]);
+	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));
+	      }
+	      return null;
+	    }
+	    return createChainableTypeChecker(validate);
+	  }
+
+	  function createEnumTypeChecker(expectedValues) {
+	    if (!Array.isArray(expectedValues)) {
+	      if (process.env.NODE_ENV !== 'production') {
+	        if (arguments.length > 1) {
+	          printWarning(
+	            'Invalid arguments supplied to oneOf, expected an array, got ' + arguments.length + ' arguments. ' +
+	            'A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z]).'
+	          );
+	        } else {
+	          printWarning('Invalid argument supplied to oneOf, expected an array.');
+	        }
+	      }
+	      return emptyFunctionThatReturnsNull;
+	    }
+
+	    function validate(props, propName, componentName, location, propFullName) {
+	      var propValue = props[propName];
+	      for (var i = 0; i < expectedValues.length; i++) {
+	        if (is(propValue, expectedValues[i])) {
+	          return null;
+	        }
+	      }
+
+	      var valuesString = JSON.stringify(expectedValues, function replacer(key, value) {
+	        var type = getPreciseType(value);
+	        if (type === 'symbol') {
+	          return String(value);
+	        }
+	        return value;
+	      });
+	      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + String(propValue) + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));
+	    }
+	    return createChainableTypeChecker(validate);
+	  }
+
+	  function createObjectOfTypeChecker(typeChecker) {
+	    function validate(props, propName, componentName, location, propFullName) {
+	      if (typeof typeChecker !== 'function') {
+	        return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');
+	      }
+	      var propValue = props[propName];
+	      var propType = getPropType(propValue);
+	      if (propType !== 'object') {
+	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));
+	      }
+	      for (var key in propValue) {
+	        if (has(propValue, key)) {
+	          var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+	          if (error instanceof Error) {
+	            return error;
+	          }
+	        }
+	      }
+	      return null;
+	    }
+	    return createChainableTypeChecker(validate);
+	  }
+
+	  function createUnionTypeChecker(arrayOfTypeCheckers) {
+	    if (!Array.isArray(arrayOfTypeCheckers)) {
+	      process.env.NODE_ENV !== 'production' ? printWarning('Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;
+	      return emptyFunctionThatReturnsNull;
+	    }
+
+	    for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
+	      var checker = arrayOfTypeCheckers[i];
+	      if (typeof checker !== 'function') {
+	        printWarning(
+	          'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' +
+	          'received ' + getPostfixForTypeWarning(checker) + ' at index ' + i + '.'
+	        );
+	        return emptyFunctionThatReturnsNull;
+	      }
+	    }
+
+	    function validate(props, propName, componentName, location, propFullName) {
+	      for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
+	        var checker = arrayOfTypeCheckers[i];
+	        if (checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret) == null) {
+	          return null;
+	        }
+	      }
+
+	      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.'));
+	    }
+	    return createChainableTypeChecker(validate);
+	  }
+
+	  function createNodeChecker() {
+	    function validate(props, propName, componentName, location, propFullName) {
+	      if (!isNode(props[propName])) {
+	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));
+	      }
+	      return null;
+	    }
+	    return createChainableTypeChecker(validate);
+	  }
+
+	  function createShapeTypeChecker(shapeTypes) {
+	    function validate(props, propName, componentName, location, propFullName) {
+	      var propValue = props[propName];
+	      var propType = getPropType(propValue);
+	      if (propType !== 'object') {
+	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
+	      }
+	      for (var key in shapeTypes) {
+	        var checker = shapeTypes[key];
+	        if (!checker) {
+	          continue;
+	        }
+	        var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+	        if (error) {
+	          return error;
+	        }
+	      }
+	      return null;
+	    }
+	    return createChainableTypeChecker(validate);
+	  }
+
+	  function createStrictShapeTypeChecker(shapeTypes) {
+	    function validate(props, propName, componentName, location, propFullName) {
+	      var propValue = props[propName];
+	      var propType = getPropType(propValue);
+	      if (propType !== 'object') {
+	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
+	      }
+	      // We need to check all keys in case some are required but missing from
+	      // props.
+	      var allKeys = assign({}, props[propName], shapeTypes);
+	      for (var key in allKeys) {
+	        var checker = shapeTypes[key];
+	        if (!checker) {
+	          return new PropTypeError(
+	            'Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' +
+	            '\nBad object: ' + JSON.stringify(props[propName], null, '  ') +
+	            '\nValid keys: ' +  JSON.stringify(Object.keys(shapeTypes), null, '  ')
+	          );
+	        }
+	        var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+	        if (error) {
+	          return error;
+	        }
+	      }
+	      return null;
+	    }
+
+	    return createChainableTypeChecker(validate);
+	  }
+
+	  function isNode(propValue) {
+	    switch (typeof propValue) {
+	      case 'number':
+	      case 'string':
+	      case 'undefined':
+	        return true;
+	      case 'boolean':
+	        return !propValue;
+	      case 'object':
+	        if (Array.isArray(propValue)) {
+	          return propValue.every(isNode);
+	        }
+	        if (propValue === null || isValidElement(propValue)) {
+	          return true;
+	        }
+
+	        var iteratorFn = getIteratorFn(propValue);
+	        if (iteratorFn) {
+	          var iterator = iteratorFn.call(propValue);
+	          var step;
+	          if (iteratorFn !== propValue.entries) {
+	            while (!(step = iterator.next()).done) {
+	              if (!isNode(step.value)) {
+	                return false;
+	              }
+	            }
+	          } else {
+	            // Iterator will provide entry [k,v] tuples rather than values.
+	            while (!(step = iterator.next()).done) {
+	              var entry = step.value;
+	              if (entry) {
+	                if (!isNode(entry[1])) {
+	                  return false;
+	                }
+	              }
+	            }
+	          }
+	        } else {
+	          return false;
+	        }
+
+	        return true;
+	      default:
+	        return false;
+	    }
+	  }
+
+	  function isSymbol(propType, propValue) {
+	    // Native Symbol.
+	    if (propType === 'symbol') {
+	      return true;
+	    }
+
+	    // falsy value can't be a Symbol
+	    if (!propValue) {
+	      return false;
+	    }
+
+	    // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'
+	    if (propValue['@@toStringTag'] === 'Symbol') {
+	      return true;
+	    }
+
+	    // Fallback for non-spec compliant Symbols which are polyfilled.
+	    if (typeof Symbol === 'function' && propValue instanceof Symbol) {
+	      return true;
+	    }
+
+	    return false;
+	  }
+
+	  // Equivalent of `typeof` but with special handling for array and regexp.
+	  function getPropType(propValue) {
+	    var propType = typeof propValue;
+	    if (Array.isArray(propValue)) {
+	      return 'array';
+	    }
+	    if (propValue instanceof RegExp) {
+	      // Old webkits (at least until Android 4.0) return 'function' rather than
+	      // 'object' for typeof a RegExp. We'll normalize this here so that /bla/
+	      // passes PropTypes.object.
+	      return 'object';
+	    }
+	    if (isSymbol(propType, propValue)) {
+	      return 'symbol';
+	    }
+	    return propType;
+	  }
+
+	  // This handles more types than `getPropType`. Only used for error messages.
+	  // See `createPrimitiveTypeChecker`.
+	  function getPreciseType(propValue) {
+	    if (typeof propValue === 'undefined' || propValue === null) {
+	      return '' + propValue;
+	    }
+	    var propType = getPropType(propValue);
+	    if (propType === 'object') {
+	      if (propValue instanceof Date) {
+	        return 'date';
+	      } else if (propValue instanceof RegExp) {
+	        return 'regexp';
+	      }
+	    }
+	    return propType;
+	  }
+
+	  // Returns a string that is postfixed to a warning about an invalid type.
+	  // For example, "undefined" or "of type array"
+	  function getPostfixForTypeWarning(value) {
+	    var type = getPreciseType(value);
+	    switch (type) {
+	      case 'array':
+	      case 'object':
+	        return 'an ' + type;
+	      case 'boolean':
+	      case 'date':
+	      case 'regexp':
+	        return 'a ' + type;
+	      default:
+	        return type;
+	    }
+	  }
+
+	  // Returns class name of the object, if any.
+	  function getClassName(propValue) {
+	    if (!propValue.constructor || !propValue.constructor.name) {
+	      return ANONYMOUS;
+	    }
+	    return propValue.constructor.name;
+	  }
+
+	  ReactPropTypes.checkPropTypes = checkPropTypes;
+	  ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache;
+	  ReactPropTypes.PropTypes = ReactPropTypes;
+
+	  return ReactPropTypes;
+	};
+	return factoryWithTypeCheckers;
+}
+
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var factoryWithThrowingShims;
+var hasRequiredFactoryWithThrowingShims;
+
+function requireFactoryWithThrowingShims () {
+	if (hasRequiredFactoryWithThrowingShims) return factoryWithThrowingShims;
+	hasRequiredFactoryWithThrowingShims = 1;
+
+	var ReactPropTypesSecret = requireReactPropTypesSecret();
+
+	function emptyFunction() {}
+	function emptyFunctionWithReset() {}
+	emptyFunctionWithReset.resetWarningCache = emptyFunction;
+
+	factoryWithThrowingShims = function() {
+	  function shim(props, propName, componentName, location, propFullName, secret) {
+	    if (secret === ReactPropTypesSecret) {
+	      // It is still safe when called from React.
+	      return;
+	    }
+	    var err = new Error(
+	      'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
+	      'Use PropTypes.checkPropTypes() to call them. ' +
+	      'Read more at http://fb.me/use-check-prop-types'
+	    );
+	    err.name = 'Invariant Violation';
+	    throw err;
+	  }	  shim.isRequired = shim;
+	  function getShim() {
+	    return shim;
+	  }	  // Important!
+	  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.
+	  var ReactPropTypes = {
+	    array: shim,
+	    bool: shim,
+	    func: shim,
+	    number: shim,
+	    object: shim,
+	    string: shim,
+	    symbol: shim,
+
+	    any: shim,
+	    arrayOf: getShim,
+	    element: shim,
+	    elementType: shim,
+	    instanceOf: getShim,
+	    node: shim,
+	    objectOf: getShim,
+	    oneOf: getShim,
+	    oneOfType: getShim,
+	    shape: getShim,
+	    exact: getShim,
+
+	    checkPropTypes: emptyFunctionWithReset,
+	    resetWarningCache: emptyFunction
+	  };
+
+	  ReactPropTypes.PropTypes = ReactPropTypes;
+
+	  return ReactPropTypes;
+	};
+	return factoryWithThrowingShims;
+}
+
+/**
+ * Copyright (c) 2013-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+if (process.env.NODE_ENV !== 'production') {
+  var ReactIs = requireReactIs();
+
+  // By explicitly using `prop-types` you are opting into new development behavior.
+  // http://fb.me/prop-types-in-prod
+  var throwOnDirectAccess = true;
+  propTypes$1.exports = requireFactoryWithTypeCheckers()(ReactIs.isElement, throwOnDirectAccess);
+} else {
+  // By explicitly using `prop-types` you are opting into new production behavior.
+  // http://fb.me/prop-types-in-prod
+  propTypes$1.exports = requireFactoryWithThrowingShims()();
+}
+
+var propTypes = {
+  // General
+  data: propTypes$1.exports.any,
+  loading: propTypes$1.exports.bool,
+  showPagination: propTypes$1.exports.bool,
+  showPaginationTop: propTypes$1.exports.bool,
+  showPaginationBottom: propTypes$1.exports.bool,
+  showPageSizeOptions: propTypes$1.exports.bool,
+  pageSizeOptions: propTypes$1.exports.array,
+  defaultPageSize: propTypes$1.exports.number,
+  showPageJump: propTypes$1.exports.bool,
+  collapseOnSortingChange: propTypes$1.exports.bool,
+  collapseOnPageChange: propTypes$1.exports.bool,
+  collapseOnDataChange: propTypes$1.exports.bool,
+  freezeWhenExpanded: propTypes$1.exports.bool,
+  sortable: propTypes$1.exports.bool,
+  resizable: propTypes$1.exports.bool,
+  filterable: propTypes$1.exports.bool,
+  defaultSortDesc: propTypes$1.exports.bool,
+  defaultSorted: propTypes$1.exports.array,
+  defaultFiltered: propTypes$1.exports.array,
+  defaultResized: propTypes$1.exports.array,
+  defaultExpanded: propTypes$1.exports.object,
+  defaultFilterMethod: propTypes$1.exports.func,
+  defaultSortMethod: propTypes$1.exports.func,
+
+  // Controlled State Callbacks
+  onPageChange: propTypes$1.exports.func,
+  onPageSizeChange: propTypes$1.exports.func,
+  onSortedChange: propTypes$1.exports.func,
+  onFilteredChange: propTypes$1.exports.func,
+  onResizedChange: propTypes$1.exports.func,
+  onExpandedChange: propTypes$1.exports.func,
+
+  // Pivoting
+  pivotBy: propTypes$1.exports.array,
+
+  // Key Constants
+  pivotValKey: propTypes$1.exports.string,
+  pivotIDKey: propTypes$1.exports.string,
+  subRowsKey: propTypes$1.exports.string,
+  aggregatedKey: propTypes$1.exports.string,
+  nestingLevelKey: propTypes$1.exports.string,
+  originalKey: propTypes$1.exports.string,
+  indexKey: propTypes$1.exports.string,
+  groupedByPivotKey: propTypes$1.exports.string,
+
+  // Server-side Callbacks
+  onFetchData: propTypes$1.exports.func,
+
+  // Classes
+  className: propTypes$1.exports.string,
+  style: propTypes$1.exports.object,
+
+  // Component decorators
+  getProps: propTypes$1.exports.func,
+  getTableProps: propTypes$1.exports.func,
+  getTheadGroupProps: propTypes$1.exports.func,
+  getTheadGroupTrProps: propTypes$1.exports.func,
+  getTheadGroupThProps: propTypes$1.exports.func,
+  getTheadProps: propTypes$1.exports.func,
+  getTheadTrProps: propTypes$1.exports.func,
+  getTheadThProps: propTypes$1.exports.func,
+  getTheadFilterProps: propTypes$1.exports.func,
+  getTheadFilterTrProps: propTypes$1.exports.func,
+  getTheadFilterThProps: propTypes$1.exports.func,
+  getTbodyProps: propTypes$1.exports.func,
+  getTrGroupProps: propTypes$1.exports.func,
+  getTrProps: propTypes$1.exports.func,
+  getTdProps: propTypes$1.exports.func,
+  getTfootProps: propTypes$1.exports.func,
+  getTfootTrProps: propTypes$1.exports.func,
+  getTfootTdProps: propTypes$1.exports.func,
+  getPaginationProps: propTypes$1.exports.func,
+  getLoadingProps: propTypes$1.exports.func,
+  getNoDataProps: propTypes$1.exports.func,
+  getResizerProps: propTypes$1.exports.func,
+
+  // Global Column Defaults
+  columns: propTypes$1.exports.arrayOf(propTypes$1.exports.shape({
+    // Renderers
+    Cell: propTypes$1.exports.oneOfType([propTypes$1.exports.element, propTypes$1.exports.string, propTypes$1.exports.func]),
+    Header: propTypes$1.exports.oneOfType([propTypes$1.exports.element, propTypes$1.exports.string, propTypes$1.exports.func]),
+    Footer: propTypes$1.exports.oneOfType([propTypes$1.exports.element, propTypes$1.exports.string, propTypes$1.exports.func]),
+    Aggregated: propTypes$1.exports.oneOfType([propTypes$1.exports.element, propTypes$1.exports.string, propTypes$1.exports.func]),
+    Pivot: propTypes$1.exports.oneOfType([propTypes$1.exports.element, propTypes$1.exports.string, propTypes$1.exports.func]),
+    PivotValue: propTypes$1.exports.oneOfType([propTypes$1.exports.element, propTypes$1.exports.string, propTypes$1.exports.func]),
+    Expander: propTypes$1.exports.oneOfType([propTypes$1.exports.element, propTypes$1.exports.string, propTypes$1.exports.func]),
+    Filter: propTypes$1.exports.oneOfType([propTypes$1.exports.element, propTypes$1.exports.func]),
+
+    // All Columns
+    sortable: propTypes$1.exports.bool, // use table default
+    resizable: propTypes$1.exports.bool, // use table default
+    filterable: propTypes$1.exports.bool, // use table default
+    show: propTypes$1.exports.bool,
+    minWidth: propTypes$1.exports.number,
+    minResizeWidth: propTypes$1.exports.number,
+
+    // Cells only
+    className: propTypes$1.exports.string,
+    style: propTypes$1.exports.object,
+    getProps: propTypes$1.exports.func,
+
+    // Pivot only
+    aggregate: propTypes$1.exports.func,
+
+    // Headers only
+    headerClassName: propTypes$1.exports.string,
+    headerStyle: propTypes$1.exports.object,
+    getHeaderProps: propTypes$1.exports.func,
+
+    // Footers only
+    footerClassName: propTypes$1.exports.string,
+    footerStyle: propTypes$1.exports.object,
+    getFooterProps: propTypes$1.exports.func,
+    filterMethod: propTypes$1.exports.func,
+    filterAll: propTypes$1.exports.bool,
+    sortMethod: propTypes$1.exports.func
+  })),
+
+  // Global Expander Column Defaults
+  expanderDefaults: propTypes$1.exports.shape({
+    sortable: propTypes$1.exports.bool,
+    resizable: propTypes$1.exports.bool,
+    filterable: propTypes$1.exports.bool,
+    width: propTypes$1.exports.number
+  }),
+
+  pivotDefaults: propTypes$1.exports.object,
+
+  // Text
+  previousText: propTypes$1.exports.node,
+  nextText: propTypes$1.exports.node,
+  loadingText: propTypes$1.exports.node,
+  noDataText: propTypes$1.exports.node,
+  pageText: propTypes$1.exports.node,
+  ofText: propTypes$1.exports.node,
+  rowsText: propTypes$1.exports.node,
+  pageJumpText: propTypes$1.exports.node,
+  rowsSelectorText: propTypes$1.exports.node,
+
+  // Components
+  TableComponent: propTypes$1.exports.oneOfType([propTypes$1.exports.func, propTypes$1.exports.element]),
+  TheadComponent: propTypes$1.exports.oneOfType([propTypes$1.exports.func, propTypes$1.exports.element]),
+  TbodyComponent: propTypes$1.exports.oneOfType([propTypes$1.exports.func, propTypes$1.exports.element]),
+  TrGroupComponent: propTypes$1.exports.oneOfType([propTypes$1.exports.func, propTypes$1.exports.element]),
+  TrComponent: propTypes$1.exports.oneOfType([propTypes$1.exports.func, propTypes$1.exports.element]),
+  ThComponent: propTypes$1.exports.oneOfType([propTypes$1.exports.func, propTypes$1.exports.element]),
+  TdComponent: propTypes$1.exports.oneOfType([propTypes$1.exports.func, propTypes$1.exports.element]),
+  TfootComponent: propTypes$1.exports.oneOfType([propTypes$1.exports.func, propTypes$1.exports.element]),
+  FilterComponent: propTypes$1.exports.oneOfType([propTypes$1.exports.func, propTypes$1.exports.element]),
+  ExpanderComponent: propTypes$1.exports.oneOfType([propTypes$1.exports.func, propTypes$1.exports.element]),
+  PivotValueComponent: propTypes$1.exports.oneOfType([propTypes$1.exports.func, propTypes$1.exports.element]),
+  AggregatedComponent: propTypes$1.exports.oneOfType([propTypes$1.exports.func, propTypes$1.exports.element]),
+  // this is a computed default generated using
+  PivotComponent: propTypes$1.exports.oneOfType([propTypes$1.exports.func, propTypes$1.exports.element]),
+  // the ExpanderComponent and PivotValueComponent at run-time in methods.js
+  PaginationComponent: propTypes$1.exports.oneOfType([propTypes$1.exports.func, propTypes$1.exports.element]),
+  PreviousComponent: propTypes$1.exports.oneOfType([propTypes$1.exports.func, propTypes$1.exports.element]),
+  NextComponent: propTypes$1.exports.oneOfType([propTypes$1.exports.func, propTypes$1.exports.element]),
+  LoadingComponent: propTypes$1.exports.oneOfType([propTypes$1.exports.func, propTypes$1.exports.element]),
+  NoDataComponent: propTypes$1.exports.oneOfType([propTypes$1.exports.func, propTypes$1.exports.element]),
+  ResizerComponent: propTypes$1.exports.oneOfType([propTypes$1.exports.func, propTypes$1.exports.element]),
+  PadRowComponent: propTypes$1.exports.oneOfType([propTypes$1.exports.func, propTypes$1.exports.element])
+};
+
+var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
+
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var ReactTable = function (_Methods) {
+  _inherits(ReactTable, _Methods);
+
+  function ReactTable(props) {
+    _classCallCheck(this, ReactTable);
+
+    var _this = _possibleConstructorReturn(this, (ReactTable.__proto__ || Object.getPrototypeOf(ReactTable)).call(this));
+
+    _this.getResolvedState = _this.getResolvedState.bind(_this);
+    _this.getDataModel = _this.getDataModel.bind(_this);
+    _this.getSortedData = _this.getSortedData.bind(_this);
+    _this.fireFetchData = _this.fireFetchData.bind(_this);
+    _this.getPropOrState = _this.getPropOrState.bind(_this);
+    _this.getStateOrProp = _this.getStateOrProp.bind(_this);
+    _this.filterData = _this.filterData.bind(_this);
+    _this.sortData = _this.sortData.bind(_this);
+    _this.getMinRows = _this.getMinRows.bind(_this);
+    _this.onPageChange = _this.onPageChange.bind(_this);
+    _this.onPageSizeChange = _this.onPageSizeChange.bind(_this);
+    _this.sortColumn = _this.sortColumn.bind(_this);
+    _this.filterColumn = _this.filterColumn.bind(_this);
+    _this.resizeColumnStart = _this.resizeColumnStart.bind(_this);
+    _this.resizeColumnEnd = _this.resizeColumnEnd.bind(_this);
+    _this.resizeColumnMoving = _this.resizeColumnMoving.bind(_this);
+
+    _this.state = {
+      page: props.defaultPage,
+      pageSize: props.defaultPageSize,
+      sorted: props.defaultSorted,
+      expanded: props.defaultExpanded,
+      filtered: props.defaultFiltered,
+      resized: props.defaultResized,
+      currentlyResizing: false,
+      skipNextSort: false
+    };
+    return _this;
+  }
+
+  _createClass(ReactTable, [{
+    key: 'render',
+    value: function render() {
+      var _this2 = this;
+
+      var resolvedState = this.getResolvedState();
+      var children = resolvedState.children,
+          className = resolvedState.className,
+          style = resolvedState.style,
+          getProps = resolvedState.getProps,
+          getTableProps = resolvedState.getTableProps,
+          getTheadGroupProps = resolvedState.getTheadGroupProps,
+          getTheadGroupTrProps = resolvedState.getTheadGroupTrProps,
+          getTheadGroupThProps = resolvedState.getTheadGroupThProps,
+          getTheadProps = resolvedState.getTheadProps,
+          getTheadTrProps = resolvedState.getTheadTrProps,
+          getTheadThProps = resolvedState.getTheadThProps,
+          getTheadFilterProps = resolvedState.getTheadFilterProps,
+          getTheadFilterTrProps = resolvedState.getTheadFilterTrProps,
+          getTheadFilterThProps = resolvedState.getTheadFilterThProps,
+          getTbodyProps = resolvedState.getTbodyProps,
+          getTrGroupProps = resolvedState.getTrGroupProps,
+          getTrProps = resolvedState.getTrProps,
+          getTdProps = resolvedState.getTdProps,
+          getTfootProps = resolvedState.getTfootProps,
+          getTfootTrProps = resolvedState.getTfootTrProps,
+          getTfootTdProps = resolvedState.getTfootTdProps,
+          getPaginationProps = resolvedState.getPaginationProps,
+          getLoadingProps = resolvedState.getLoadingProps,
+          getNoDataProps = resolvedState.getNoDataProps,
+          getResizerProps = resolvedState.getResizerProps,
+          showPagination = resolvedState.showPagination,
+          showPaginationTop = resolvedState.showPaginationTop,
+          showPaginationBottom = resolvedState.showPaginationBottom,
+          manual = resolvedState.manual,
+          loadingText = resolvedState.loadingText,
+          noDataText = resolvedState.noDataText,
+          sortable = resolvedState.sortable,
+          multiSort = resolvedState.multiSort,
+          resizable = resolvedState.resizable,
+          filterable = resolvedState.filterable,
+          pivotIDKey = resolvedState.pivotIDKey,
+          pivotValKey = resolvedState.pivotValKey,
+          pivotBy = resolvedState.pivotBy,
+          subRowsKey = resolvedState.subRowsKey,
+          aggregatedKey = resolvedState.aggregatedKey,
+          originalKey = resolvedState.originalKey,
+          indexKey = resolvedState.indexKey,
+          groupedByPivotKey = resolvedState.groupedByPivotKey,
+          loading = resolvedState.loading,
+          pageSize = resolvedState.pageSize,
+          page = resolvedState.page,
+          sorted = resolvedState.sorted,
+          filtered = resolvedState.filtered,
+          resized = resolvedState.resized,
+          expanded = resolvedState.expanded,
+          pages = resolvedState.pages,
+          onExpandedChange = resolvedState.onExpandedChange,
+          TableComponent = resolvedState.TableComponent,
+          TheadComponent = resolvedState.TheadComponent,
+          TbodyComponent = resolvedState.TbodyComponent,
+          TrGroupComponent = resolvedState.TrGroupComponent,
+          TrComponent = resolvedState.TrComponent,
+          ThComponent = resolvedState.ThComponent,
+          TdComponent = resolvedState.TdComponent,
+          TfootComponent = resolvedState.TfootComponent,
+          PaginationComponent = resolvedState.PaginationComponent,
+          LoadingComponent = resolvedState.LoadingComponent,
+          SubComponent = resolvedState.SubComponent,
+          NoDataComponent = resolvedState.NoDataComponent,
+          ResizerComponent = resolvedState.ResizerComponent,
+          ExpanderComponent = resolvedState.ExpanderComponent,
+          PivotValueComponent = resolvedState.PivotValueComponent,
+          PivotComponent = resolvedState.PivotComponent,
+          AggregatedComponent = resolvedState.AggregatedComponent,
+          FilterComponent = resolvedState.FilterComponent,
+          PadRowComponent = resolvedState.PadRowComponent,
+          resolvedData = resolvedState.resolvedData,
+          allVisibleColumns = resolvedState.allVisibleColumns,
+          headerGroups = resolvedState.headerGroups,
+          hasHeaderGroups = resolvedState.hasHeaderGroups,
+          sortedData = resolvedState.sortedData,
+          currentlyResizing = resolvedState.currentlyResizing;
+
+      // Pagination
+
+      var startRow = pageSize * page;
+      var endRow = startRow + pageSize;
+      var pageRows = manual ? resolvedData : sortedData.slice(startRow, endRow);
+      var minRows = this.getMinRows();
+      var padRows = _.range(Math.max(minRows - pageRows.length, 0));
+
+      var hasColumnFooter = allVisibleColumns.some(function (d) {
+        return d.Footer;
+      });
+      var hasFilters = filterable || allVisibleColumns.some(function (d) {
+        return d.filterable;
+      });
+
+      var recurseRowsViewIndex = function recurseRowsViewIndex(rows) {
+        var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+        var index = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
+        return [rows.map(function (row, i) {
+          index += 1;
+          var rowWithViewIndex = _extends({}, row, {
+            _viewIndex: index
+          });
+          var newPath = path.concat([i]);
+          if (rowWithViewIndex[subRowsKey] && _.get(expanded, newPath)) {
+            var _recurseRowsViewIndex = recurseRowsViewIndex(rowWithViewIndex[subRowsKey], newPath, index);
+
+            var _recurseRowsViewIndex2 = _slicedToArray(_recurseRowsViewIndex, 2);
+
+            rowWithViewIndex[subRowsKey] = _recurseRowsViewIndex2[0];
+            index = _recurseRowsViewIndex2[1];
+          }
+          return rowWithViewIndex;
+        }), index];
+      };
+
+      var _recurseRowsViewIndex3 = recurseRowsViewIndex(pageRows);
+
+      var _recurseRowsViewIndex4 = _slicedToArray(_recurseRowsViewIndex3, 1);
+
+      pageRows = _recurseRowsViewIndex4[0];
+
+
+      var canPrevious = page > 0;
+      var canNext = page + 1 < pages;
+
+      var rowMinWidth = _.sum(allVisibleColumns.map(function (d) {
+        var resizedColumn = resized.find(function (x) {
+          return x.id === d.id;
+        }) || {};
+        return _.getFirstDefined(resizedColumn.value, d.width, d.minWidth);
+      }));
+
+      var rowIndex = -1;
+
+      var finalState = _extends({}, resolvedState, {
+        startRow: startRow,
+        endRow: endRow,
+        pageRows: pageRows,
+        minRows: minRows,
+        padRows: padRows,
+        hasColumnFooter: hasColumnFooter,
+        canPrevious: canPrevious,
+        canNext: canNext,
+        rowMinWidth: rowMinWidth
+      });
+
+      var rootProps = _.splitProps(getProps(finalState, undefined, undefined, this));
+      var tableProps = _.splitProps(getTableProps(finalState, undefined, undefined, this));
+      var tBodyProps = _.splitProps(getTbodyProps(finalState, undefined, undefined, this));
+      var loadingProps = getLoadingProps(finalState, undefined, undefined, this);
+      var noDataProps = getNoDataProps(finalState, undefined, undefined, this);
+
+      // Visual Components
+
+      var makeHeaderGroup = function makeHeaderGroup(column, i) {
+        var resizedValue = function resizedValue(col) {
+          return (resized.find(function (x) {
+            return x.id === col.id;
+          }) || {}).value;
+        };
+        var flex = _.sum(column.columns.map(function (col) {
+          return col.width || resizedValue(col) ? 0 : col.minWidth;
+        }));
+        var width = _.sum(column.columns.map(function (col) {
+          return _.getFirstDefined(resizedValue(col), col.width, col.minWidth);
+        }));
+        var maxWidth = _.sum(column.columns.map(function (col) {
+          return _.getFirstDefined(resizedValue(col), col.width, col.maxWidth);
+        }));
+
+        var theadGroupThProps = _.splitProps(getTheadGroupThProps(finalState, undefined, column, _this2));
+        var columnHeaderProps = _.splitProps(column.getHeaderProps(finalState, undefined, column, _this2));
+
+        var classes = [column.headerClassName, theadGroupThProps.className, columnHeaderProps.className];
+
+        var styles = _extends({}, column.headerStyle, theadGroupThProps.style, columnHeaderProps.style);
+
+        var rest = _extends({}, theadGroupThProps.rest, columnHeaderProps.rest);
+
+        var flexStyles = {
+          flex: flex + ' 0 auto',
+          width: _.asPx(width),
+          maxWidth: _.asPx(maxWidth)
+        };
+
+        return React__default["default"].createElement(
+          ThComponent,
+          _extends({
+            key: i + '-' + column.id,
+            className: classnames__default["default"](classes),
+            style: _extends({}, styles, flexStyles)
+          }, rest),
+          _.normalizeComponent(column.Header, {
+            data: sortedData,
+            column: column
+          })
+        );
+      };
+
+      var makeHeaderGroups = function makeHeaderGroups() {
+        var theadGroupProps = _.splitProps(getTheadGroupProps(finalState, undefined, undefined, _this2));
+        var theadGroupTrProps = _.splitProps(getTheadGroupTrProps(finalState, undefined, undefined, _this2));
+        return React__default["default"].createElement(
+          TheadComponent,
+          _extends({
+            className: classnames__default["default"]('-headerGroups', theadGroupProps.className),
+            style: _extends({}, theadGroupProps.style, {
+              minWidth: rowMinWidth + 'px'
+            })
+          }, theadGroupProps.rest),
+          React__default["default"].createElement(
+            TrComponent,
+            _extends({
+              className: theadGroupTrProps.className,
+              style: theadGroupTrProps.style
+            }, theadGroupTrProps.rest),
+            headerGroups.map(makeHeaderGroup)
+          )
+        );
+      };
+
+      var makeHeader = function makeHeader(column, i) {
+        var resizedCol = resized.find(function (x) {
+          return x.id === column.id;
+        }) || {};
+        var sort = sorted.find(function (d) {
+          return d.id === column.id;
+        });
+        var show = typeof column.show === 'function' ? column.show() : column.show;
+        var width = _.getFirstDefined(resizedCol.value, column.width, column.minWidth);
+        var maxWidth = _.getFirstDefined(resizedCol.value, column.width, column.maxWidth);
+        var theadThProps = _.splitProps(getTheadThProps(finalState, undefined, column, _this2));
+        var columnHeaderProps = _.splitProps(column.getHeaderProps(finalState, undefined, column, _this2));
+
+        var classes = [column.headerClassName, theadThProps.className, columnHeaderProps.className];
+
+        var styles = _extends({}, column.headerStyle, theadThProps.style, columnHeaderProps.style);
+
+        var rest = _extends({}, theadThProps.rest, columnHeaderProps.rest);
+
+        var isResizable = _.getFirstDefined(column.resizable, resizable, false);
+        var resizer = isResizable ? React__default["default"].createElement(ResizerComponent, _extends({
+          onMouseDown: function onMouseDown(e) {
+            return _this2.resizeColumnStart(e, column, false);
+          },
+          onTouchStart: function onTouchStart(e) {
+            return _this2.resizeColumnStart(e, column, true);
+          }
+        }, getResizerProps('finalState', undefined, column, _this2))) : null;
+
+        var isSortable = _.getFirstDefined(column.sortable, sortable, false);
+
+        return React__default["default"].createElement(
+          ThComponent,
+          _extends({
+            key: i + '-' + column.id,
+            className: classnames__default["default"](classes, isResizable && 'rt-resizable-header', sort ? sort.desc ? '-sort-desc' : '-sort-asc' : '', isSortable && '-cursor-pointer', !show && '-hidden', pivotBy && pivotBy.slice(0, -1).includes(column.id) && 'rt-header-pivot'),
+            style: _extends({}, styles, {
+              flex: width + ' 0 auto',
+              width: _.asPx(width),
+              maxWidth: _.asPx(maxWidth)
+            }),
+            toggleSort: function toggleSort(e) {
+              if (isSortable) _this2.sortColumn(column, multiSort ? e.shiftKey : false);
+            }
+          }, rest),
+          React__default["default"].createElement(
+            'div',
+            { className: classnames__default["default"](isResizable && 'rt-resizable-header-content') },
+            _.normalizeComponent(column.Header, {
+              data: sortedData,
+              column: column
+            })
+          ),
+          resizer
+        );
+      };
+
+      var makeHeaders = function makeHeaders() {
+        var theadProps = _.splitProps(getTheadProps(finalState, undefined, undefined, _this2));
+        var theadTrProps = _.splitProps(getTheadTrProps(finalState, undefined, undefined, _this2));
+        return React__default["default"].createElement(
+          TheadComponent,
+          _extends({
+            className: classnames__default["default"]('-header', theadProps.className),
+            style: _extends({}, theadProps.style, {
+              minWidth: rowMinWidth + 'px'
+            })
+          }, theadProps.rest),
+          React__default["default"].createElement(
+            TrComponent,
+            _extends({
+              className: theadTrProps.className,
+              style: theadTrProps.style
+            }, theadTrProps.rest),
+            allVisibleColumns.map(makeHeader)
+          )
+        );
+      };
+
+      var makeFilter = function makeFilter(column, i) {
+        var resizedCol = resized.find(function (x) {
+          return x.id === column.id;
+        }) || {};
+        var width = _.getFirstDefined(resizedCol.value, column.width, column.minWidth);
+        var maxWidth = _.getFirstDefined(resizedCol.value, column.width, column.maxWidth);
+        var theadFilterThProps = _.splitProps(getTheadFilterThProps(finalState, undefined, column, _this2));
+        var columnHeaderProps = _.splitProps(column.getHeaderProps(finalState, undefined, column, _this2));
+
+        var classes = [column.headerClassName, theadFilterThProps.className, columnHeaderProps.className];
+
+        var styles = _extends({}, column.headerStyle, theadFilterThProps.style, columnHeaderProps.style);
+
+        var rest = _extends({}, theadFilterThProps.rest, columnHeaderProps.rest);
+
+        var filter = filtered.find(function (filter) {
+          return filter.id === column.id;
+        });
+
+        var ResolvedFilterComponent = column.Filter || FilterComponent;
+
+        var isFilterable = _.getFirstDefined(column.filterable, filterable, false);
+
+        return React__default["default"].createElement(
+          ThComponent,
+          _extends({
+            key: i + '-' + column.id,
+            className: classnames__default["default"](classes),
+            style: _extends({}, styles, {
+              flex: width + ' 0 auto',
+              width: _.asPx(width),
+              maxWidth: _.asPx(maxWidth)
+            })
+          }, rest),
+          isFilterable ? _.normalizeComponent(ResolvedFilterComponent, {
+            column: column,
+            filter: filter,
+            onChange: function onChange(value) {
+              return _this2.filterColumn(column, value);
+            }
+          }, defaultProps.column.Filter) : null
+        );
+      };
+
+      var makeFilters = function makeFilters() {
+        var theadFilterProps = _.splitProps(getTheadFilterProps(finalState, undefined, undefined, _this2));
+        var theadFilterTrProps = _.splitProps(getTheadFilterTrProps(finalState, undefined, undefined, _this2));
+        return React__default["default"].createElement(
+          TheadComponent,
+          _extends({
+            className: classnames__default["default"]('-filters', theadFilterProps.className),
+            style: _extends({}, theadFilterProps.style, {
+              minWidth: rowMinWidth + 'px'
+            })
+          }, theadFilterProps.rest),
+          React__default["default"].createElement(
+            TrComponent,
+            _extends({
+              className: theadFilterTrProps.className,
+              style: theadFilterTrProps.style
+            }, theadFilterTrProps.rest),
+            allVisibleColumns.map(makeFilter)
+          )
+        );
+      };
+
+      var makePageRow = function makePageRow(row, i) {
+        var path = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+
+        var rowInfo = {
+          original: row[originalKey],
+          row: row,
+          index: row[indexKey],
+          viewIndex: rowIndex += 1,
+          pageSize: pageSize,
+          page: page,
+          level: path.length,
+          nestingPath: path.concat([i]),
+          aggregated: row[aggregatedKey],
+          groupedByPivot: row[groupedByPivotKey],
+          subRows: row[subRowsKey]
+        };
+        var isExpanded = _.get(expanded, rowInfo.nestingPath);
+        var trGroupProps = getTrGroupProps(finalState, rowInfo, undefined, _this2);
+        var trProps = _.splitProps(getTrProps(finalState, rowInfo, undefined, _this2));
+        return React__default["default"].createElement(
+          TrGroupComponent,
+          _extends({ key: rowInfo.nestingPath.join('_') }, trGroupProps),
+          React__default["default"].createElement(
+            TrComponent,
+            _extends({
+              className: classnames__default["default"](trProps.className, row._viewIndex % 2 ? '-even' : '-odd'),
+              style: trProps.style
+            }, trProps.rest),
+            allVisibleColumns.map(function (column, i2) {
+              var resizedCol = resized.find(function (x) {
+                return x.id === column.id;
+              }) || {};
+              var show = typeof column.show === 'function' ? column.show() : column.show;
+              var width = _.getFirstDefined(resizedCol.value, column.width, column.minWidth);
+              var maxWidth = _.getFirstDefined(resizedCol.value, column.width, column.maxWidth);
+              var tdProps = _.splitProps(getTdProps(finalState, rowInfo, column, _this2));
+              var columnProps = _.splitProps(column.getProps(finalState, rowInfo, column, _this2));
+
+              var classes = [tdProps.className, column.className, columnProps.className];
+
+              var styles = _extends({}, tdProps.style, column.style, columnProps.style);
+
+              var cellInfo = _extends({}, rowInfo, {
+                isExpanded: isExpanded,
+                column: _extends({}, column),
+                value: rowInfo.row[column.id],
+                pivoted: column.pivoted,
+                expander: column.expander,
+                resized: resized,
+                show: show,
+                width: width,
+                maxWidth: maxWidth,
+                tdProps: tdProps,
+                columnProps: columnProps,
+                classes: classes,
+                styles: styles
+              });
+
+              var value = cellInfo.value;
+
+              var useOnExpanderClick = void 0;
+              var isBranch = void 0;
+              var isPreview = void 0;
+
+              var onExpanderClick = function onExpanderClick(e) {
+                var newExpanded = _.clone(expanded);
+                if (isExpanded) {
+                  newExpanded = _.set(newExpanded, cellInfo.nestingPath, false);
+                } else {
+                  newExpanded = _.set(newExpanded, cellInfo.nestingPath, {});
+                }
+
+                return _this2.setStateWithData({
+                  expanded: newExpanded
+                }, function () {
+                  return onExpandedChange && onExpandedChange(newExpanded, cellInfo.nestingPath, e, cellInfo);
+                });
+              };
+
+              // Default to a standard cell
+              var resolvedCell = _.normalizeComponent(column.Cell, cellInfo, value);
+
+              // Resolve Renderers
+              var ResolvedAggregatedComponent = column.Aggregated || (!column.aggregate ? AggregatedComponent : column.Cell);
+              var ResolvedExpanderComponent = column.Expander || ExpanderComponent;
+              var ResolvedPivotValueComponent = column.PivotValue || PivotValueComponent;
+              var DefaultResolvedPivotComponent = PivotComponent || function (props) {
+                return React__default["default"].createElement(
+                  'div',
+                  null,
+                  React__default["default"].createElement(ResolvedExpanderComponent, props),
+                  React__default["default"].createElement(ResolvedPivotValueComponent, props)
+                );
+              };
+              var ResolvedPivotComponent = column.Pivot || DefaultResolvedPivotComponent;
+
+              // Is this cell expandable?
+              if (cellInfo.pivoted || cellInfo.expander) {
+                // Make it expandable by defualt
+                cellInfo.expandable = true;
+                useOnExpanderClick = true;
+                // If pivoted, has no subRows, and does not have a subComponent,
+                // do not make expandable
+                if (cellInfo.pivoted && !cellInfo.subRows && !SubComponent) {
+                  cellInfo.expandable = false;
+                }
+              }
+
+              if (cellInfo.pivoted) {
+                // Is this column a branch?
+                isBranch = rowInfo.row[pivotIDKey] === column.id && cellInfo.subRows;
+                // Should this column be blank?
+                isPreview = pivotBy.indexOf(column.id) > pivotBy.indexOf(rowInfo.row[pivotIDKey]) && cellInfo.subRows;
+                // Pivot Cell Render Override
+                if (isBranch) {
+                  // isPivot
+                  resolvedCell = _.normalizeComponent(ResolvedPivotComponent, _extends({}, cellInfo, {
+                    value: row[pivotValKey]
+                  }), row[pivotValKey]);
+                } else if (isPreview) {
+                  // Show the pivot preview
+                  resolvedCell = _.normalizeComponent(ResolvedAggregatedComponent, cellInfo, value);
+                } else {
+                  resolvedCell = null;
+                }
+              } else if (cellInfo.aggregated) {
+                resolvedCell = _.normalizeComponent(ResolvedAggregatedComponent, cellInfo, value);
+              }
+
+              if (cellInfo.expander) {
+                resolvedCell = _.normalizeComponent(ResolvedExpanderComponent, cellInfo, row[pivotValKey]);
+                if (pivotBy) {
+                  if (cellInfo.groupedByPivot) {
+                    resolvedCell = null;
+                  }
+                  if (!cellInfo.subRows && !SubComponent) {
+                    resolvedCell = null;
+                  }
+                }
+              }
+
+              var resolvedOnExpanderClick = useOnExpanderClick ? onExpanderClick : function () {};
+
+              // If there are multiple onClick events, make sure they don't
+              // override eachother. This should maybe be expanded to handle all
+              // function attributes
+              var interactionProps = {
+                onClick: resolvedOnExpanderClick
+              };
+
+              if (tdProps.rest.onClick) {
+                interactionProps.onClick = function (e) {
+                  tdProps.rest.onClick(e, function () {
+                    return resolvedOnExpanderClick(e);
+                  });
+                };
+              }
+
+              if (columnProps.rest.onClick) {
+                interactionProps.onClick = function (e) {
+                  columnProps.rest.onClick(e, function () {
+                    return resolvedOnExpanderClick(e);
+                  });
+                };
+              }
+
+              // Return the cell
+              return React__default["default"].createElement(
+                TdComponent
+                // eslint-disable-next-line react/no-array-index-key
+                ,
+                _extends({ key: i2 + '-' + column.id,
+                  className: classnames__default["default"](classes, !cellInfo.expandable && !show && 'hidden', cellInfo.expandable && 'rt-expandable', (isBranch || isPreview) && 'rt-pivot'),
+                  style: _extends({}, styles, {
+                    flex: width + ' 0 auto',
+                    width: _.asPx(width),
+                    maxWidth: _.asPx(maxWidth)
+                  })
+                }, tdProps.rest, columnProps.rest, interactionProps),
+                resolvedCell
+              );
+            })
+          ),
+          rowInfo.subRows && isExpanded && rowInfo.subRows.map(function (d, i) {
+            return makePageRow(d, i, rowInfo.nestingPath);
+          }),
+          SubComponent && !rowInfo.subRows && isExpanded && SubComponent(rowInfo, function () {
+            var newExpanded = _.clone(expanded);
+
+            _.set(newExpanded, rowInfo.nestingPath, false);
+          })
+        );
+      };
+
+      var makePadColumn = function makePadColumn(column, i) {
+        var resizedCol = resized.find(function (x) {
+          return x.id === column.id;
+        }) || {};
+        var show = typeof column.show === 'function' ? column.show() : column.show;
+        var width = _.getFirstDefined(resizedCol.value, column.width, column.minWidth);
+        var flex = width;
+        var maxWidth = _.getFirstDefined(resizedCol.value, column.width, column.maxWidth);
+        var tdProps = _.splitProps(getTdProps(finalState, undefined, column, _this2));
+        var columnProps = _.splitProps(column.getProps(finalState, undefined, column, _this2));
+
+        var classes = [tdProps.className, column.className, columnProps.className];
+
+        var styles = _extends({}, tdProps.style, column.style, columnProps.style);
+
+        return React__default["default"].createElement(
+          TdComponent,
+          _extends({
+            key: i + '-' + column.id,
+            className: classnames__default["default"](classes, !show && 'hidden'),
+            style: _extends({}, styles, {
+              flex: flex + ' 0 auto',
+              width: _.asPx(width),
+              maxWidth: _.asPx(maxWidth)
+            })
+          }, tdProps.rest),
+          _.normalizeComponent(PadRowComponent)
+        );
+      };
+
+      var makePadRow = function makePadRow(row, i) {
+        var trGroupProps = getTrGroupProps(finalState, undefined, undefined, _this2);
+        var trProps = _.splitProps(getTrProps(finalState, undefined, undefined, _this2));
+        return React__default["default"].createElement(
+          TrGroupComponent,
+          _extends({ key: 'pad-' + i }, trGroupProps),
+          React__default["default"].createElement(
+            TrComponent,
+            {
+              className: classnames__default["default"]('-padRow', (pageRows.length + i) % 2 ? '-even' : '-odd', trProps.className),
+              style: trProps.style || {}
+            },
+            allVisibleColumns.map(makePadColumn)
+          )
+        );
+      };
+
+      var makeColumnFooter = function makeColumnFooter(column, i) {
+        var resizedCol = resized.find(function (x) {
+          return x.id === column.id;
+        }) || {};
+        var show = typeof column.show === 'function' ? column.show() : column.show;
+        var width = _.getFirstDefined(resizedCol.value, column.width, column.minWidth);
+        var maxWidth = _.getFirstDefined(resizedCol.value, column.width, column.maxWidth);
+        var tFootTdProps = _.splitProps(getTfootTdProps(finalState, undefined, undefined, _this2));
+        var columnProps = _.splitProps(column.getProps(finalState, undefined, column, _this2));
+        var columnFooterProps = _.splitProps(column.getFooterProps(finalState, undefined, column, _this2));
+
+        var classes = [tFootTdProps.className, column.className, columnProps.className, columnFooterProps.className];
+
+        var styles = _extends({}, tFootTdProps.style, column.style, columnProps.style, columnFooterProps.style);
+
+        return React__default["default"].createElement(
+          TdComponent,
+          _extends({
+            key: i + '-' + column.id,
+            className: classnames__default["default"](classes, !show && 'hidden'),
+            style: _extends({}, styles, {
+              flex: width + ' 0 auto',
+              width: _.asPx(width),
+              maxWidth: _.asPx(maxWidth)
+            })
+          }, columnProps.rest, tFootTdProps.rest, columnFooterProps.rest),
+          _.normalizeComponent(column.Footer, {
+            data: sortedData,
+            column: column
+          })
+        );
+      };
+
+      var makeColumnFooters = function makeColumnFooters() {
+        var tFootProps = _.splitProps(getTfootProps(finalState, undefined, undefined, _this2));
+        var tFootTrProps = _.splitProps(getTfootTrProps(finalState, undefined, undefined, _this2));
+        return React__default["default"].createElement(
+          TfootComponent,
+          _extends({
+            className: tFootProps.className,
+            style: _extends({}, tFootProps.style, {
+              minWidth: rowMinWidth + 'px'
+            })
+          }, tFootProps.rest),
+          React__default["default"].createElement(
+            TrComponent,
+            _extends({
+              className: classnames__default["default"](tFootTrProps.className),
+              style: tFootTrProps.style
+            }, tFootTrProps.rest),
+            allVisibleColumns.map(makeColumnFooter)
+          )
+        );
+      };
+
+      var makePagination = function makePagination(isTop) {
+        var paginationProps = _.splitProps(getPaginationProps(finalState, undefined, undefined, _this2));
+        return React__default["default"].createElement(PaginationComponent, _extends({}, resolvedState, {
+          pages: pages,
+          canPrevious: canPrevious,
+          canNext: canNext,
+          onPageChange: _this2.onPageChange,
+          onPageSizeChange: _this2.onPageSizeChange,
+          className: paginationProps.className,
+          style: paginationProps.style,
+          isTop: isTop
+        }, paginationProps.rest));
+      };
+
+      var makeTable = function makeTable() {
+        return React__default["default"].createElement(
+          'div',
+          _extends({
+            className: classnames__default["default"]('ReactTable', className, rootProps.className),
+            style: _extends({}, style, rootProps.style)
+          }, rootProps.rest),
+          showPagination && showPaginationTop ? React__default["default"].createElement(
+            'div',
+            { className: 'pagination-top' },
+            makePagination(true)
+          ) : null,
+          React__default["default"].createElement(
+            TableComponent,
+            _extends({
+              className: classnames__default["default"](tableProps.className, currentlyResizing ? 'rt-resizing' : ''),
+              style: tableProps.style
+            }, tableProps.rest),
+            hasHeaderGroups ? makeHeaderGroups() : null,
+            makeHeaders(),
+            hasFilters ? makeFilters() : null,
+            React__default["default"].createElement(
+              TbodyComponent,
+              _extends({
+                className: classnames__default["default"](tBodyProps.className),
+                style: _extends({}, tBodyProps.style, {
+                  minWidth: rowMinWidth + 'px'
+                })
+              }, tBodyProps.rest),
+              pageRows.map(function (d, i) {
+                return makePageRow(d, i);
+              }),
+              padRows.map(makePadRow)
+            ),
+            hasColumnFooter ? makeColumnFooters() : null
+          ),
+          showPagination && showPaginationBottom ? React__default["default"].createElement(
+            'div',
+            { className: 'pagination-bottom' },
+            makePagination(false)
+          ) : null,
+          !pageRows.length && React__default["default"].createElement(
+            NoDataComponent,
+            noDataProps,
+            _.normalizeComponent(noDataText)
+          ),
+          React__default["default"].createElement(LoadingComponent, _extends({ loading: loading, loadingText: loadingText }, loadingProps))
+        );
+      };
+
+      // childProps are optionally passed to a function-as-a-child
+      return children ? children(finalState, makeTable, this) : makeTable();
+    }
+  }]);
+
+  return ReactTable;
+}(Methods(Lifecycle(React.Component)));
+
+ReactTable.propTypes = propTypes;
+ReactTable.defaultProps = defaultProps;
+
 var _a$2;
 function frequencyOutput(frequency) {
     if (frequency === 0) {
@@ -1158,7 +5006,7 @@ var GnomadFrequencyTable = /** @class */ (function (_super) {
         writable: true,
         value: function () {
             return (React__namespace.createElement("div", { className: "gnomad-frequency-table", "data-test": "gnomad-table" },
-                React__namespace.createElement(ReactTable__default["default"], { data: this.props.data, showPagination: false, pageSize: this.props.data.length, sortable: false, className: "-striped -highlight", getTrProps: this.getTrProps, columns: [
+                React__namespace.createElement(ReactTable, { data: this.props.data, showPagination: false, pageSize: this.props.data.length, sortable: false, className: "-striped -highlight", getTrProps: this.getTrProps, columns: [
                         {
                             id: GnomadTableColumnName.population,
                             accessor: 'population',
@@ -1788,7 +5636,7 @@ var DropdownSelector = /** @class */ (function (_super) {
             var _a;
             var allValuesSelected = this.allValues.length === this.selectedValues.length;
             var classes = this.props.selectionIndicatorClassNames;
-            return classNames__default["default"](classes.base, (_a = {},
+            return classnames__default["default"](classes.base, (_a = {},
                 _a[classes.allSelected] = allValuesSelected,
                 _a[classes.partiallySelected] = !allValuesSelected,
                 _a));
@@ -2574,8 +6422,8 @@ var FilterResetPanel = /** @class */ (function (_super) {
         writable: true,
         value: {
             buttonText: 'Remove filter',
-            buttonClass: classNames__default["default"]('btn', 'btn-secondary', 'btn-sm'),
-            className: classNames__default["default"]('alert', 'alert-success', styles$7.filterResetPanel),
+            buttonClass: classnames__default["default"]('btn', 'btn-secondary', 'btn-sm'),
+            className: classnames__default["default"]('alert', 'alert-success', styles$7.filterResetPanel),
         }
     });
     FilterResetPanel = tslib.__decorate([
@@ -2997,8 +6845,8 @@ var DataTable = /** @class */ (function (_super) {
         value: function () {
             return (React__namespace.createElement("div", { className: "cbioportal-frontend" },
                 React__namespace.createElement(DataTableToolbar, { visibilityToggle: this.onVisibilityToggle, showSearchBox: this.props.showSearchBox, onSearch: this.onSearch, filterInputRef: this.filterInputRef, searchDelay: this.props.searchDelay, searchPlaceHolder: this.props.searchPlaceholder, info: this.props.info, showColumnVisibility: this.props.showColumnVisibility, columnVisibility: this.columnVisibilityDef, columnSelectorProps: this.props.columnSelectorProps }),
-                React__namespace.createElement("div", { className: classNames__default["default"](this.props.className, 'cbioportal-frontend', 'default-data-table') },
-                    React__namespace.createElement(ReactTable__default["default"], tslib.__assign({ data: this.tableData, columns: this.columns, getTrProps: this.needToCustomizeRowStyle
+                React__namespace.createElement("div", { className: classnames__default["default"](this.props.className, 'cbioportal-frontend', 'default-data-table') },
+                    React__namespace.createElement(ReactTable, tslib.__assign({ data: this.tableData, columns: this.columns, getTrProps: this.needToCustomizeRowStyle
                             ? this.getTrProps
                             : undefined, defaultSorted: this.defaultSorted, defaultPageSize: this.props.initialItemsPerPage, showPagination: this.showPagination, className: "-striped -highlight", previousText: "<", nextText: ">", expanded: this.expanded, onExpandedChange: this.onExpandedChange, onPageChange: this.resetExpander, onPageSizeChange: this.resetExpander, onSortedChange: this.resetExpander, minRows: 1 }, this.props.reactTableProps)))));
         }
@@ -5870,7 +9718,7 @@ var AxisScaleSwitch = /** @class */ (function (_super) {
         configurable: true,
         writable: true,
         value: function (scale, onClick) {
-            return (React__namespace.createElement("button", { className: classNames__default["default"]({
+            return (React__namespace.createElement("button", { className: classnames__default["default"]({
                     'btn-secondary': this.props.selectedScale === scale,
                     'btn-outline-secondary': this.props.selectedScale !== scale,
                 }, 'btn', 'btn-sm', 'btn-axis-switch'), "data-test": "AxisScaleSwitch".concat(scale), style: {
@@ -6035,7 +9883,7 @@ var LollipopMutationPlotControls = /** @class */ (function (_super) {
     });
     Object.defineProperty(LollipopMutationPlotControls.prototype, "trackSelector", {
         get: function () {
-            return (React__namespace.createElement("div", { className: classNames__default["default"]('annotation-track-selector', 'small'), style: { width: 180, marginRight: 7 } },
+            return (React__namespace.createElement("div", { className: classnames__default["default"]('annotation-track-selector', 'small'), style: { width: 180, marginRight: 7 } },
                 React__namespace.createElement(TrackSelector, { tracks: this.props.tracks, trackVisibility: this.props.trackVisibility, trackDataStatus: this.props.trackDataStatus, onChange: this.props.onTrackVisibilityChange })));
         },
         enumerable: false,
@@ -6069,7 +9917,7 @@ var LollipopMutationPlotControls = /** @class */ (function (_super) {
         configurable: true,
         writable: true,
         value: function () {
-            return (React__namespace.createElement("div", { className: classNames__default["default"]('lollipop_mutation_plot__controls', this.props.showControls
+            return (React__namespace.createElement("div", { className: classnames__default["default"]('lollipop_mutation_plot__controls', this.props.showControls
                     ? styles$5['fade-in']
                     : styles$5['fade-out']) },
                 React__namespace.createElement("div", { style: { display: 'flex', alignItems: 'center' } },
@@ -6686,7 +10534,7 @@ var Track = /** @class */ (function (_super) {
                     position: 'relative',
                     display: 'flex',
                 } },
-                React__namespace.createElement("span", { className: classNames__default["default"](styles$4.trackTitle, 'small', "".concat(this.props.isSubTrack ? 'subtrack-' : '', "trackTitle")) }, this.props.trackTitle),
+                React__namespace.createElement("span", { className: classnames__default["default"](styles$4.trackTitle, 'small', "".concat(this.props.isSubTrack ? 'subtrack-' : '', "trackTitle")) }, this.props.trackTitle),
                 React__namespace.createElement("span", null,
                     React__namespace.createElement(cbioportalFrontendCommons.DefaultTooltip, tslib.__assign({ placement: this.getOverlayPlacement(), overlay: this.getOverlay, onVisibleChange: this.onTooltipVisibleChange, destroyTooltipOnHide: true }, this.tooltipVisibleProps), this.hitZone),
                     React__namespace.createElement("span", { style: { marginLeft: this.props.xOffset }, onMouseOver: this.onMouseOver },
@@ -7292,8 +11140,8 @@ var PtmAnnotationTable = /** @class */ (function (_super) {
             var showPagination = data.length >
                 (this.props.initialItemsPerPage ||
                     PtmAnnotationTable_1.defaultProps.initialItemsPerPage);
-            return (React__namespace.createElement("div", { className: classNames__default["default"]('cbioportal-frontend', 'default-track-tooltip-table') },
-                React__namespace.createElement(ReactTable__default["default"], { data: data, columns: this.columns, defaultSorted: [
+            return (React__namespace.createElement("div", { className: classnames__default["default"]('cbioportal-frontend', 'default-track-tooltip-table') },
+                React__namespace.createElement(ReactTable, { data: data, columns: this.columns, defaultSorted: [
                         {
                             id: initialSortColumn ||
                                 PtmAnnotationTable_1.defaultProps
@@ -10832,7 +14680,7 @@ var TranscriptDropdown = /** @class */ (function (_super) {
                     canonicalTranscriptId &&
                     transcriptsWithAnnotations.result &&
                     transcriptsWithAnnotations.result.length > 0;
-                return (React__namespace.createElement("div", { className: classNames__default["default"]('small', styles$1.dropDown) },
+                return (React__namespace.createElement("div", { className: classnames__default["default"]('small', styles$1.dropDown) },
                     this.loadingIndicator(isLoading),
                     !isLoading &&
                         requiredData &&
@@ -10845,7 +14693,7 @@ var TranscriptDropdown = /** @class */ (function (_super) {
                 var requiredData = transcriptsWithProteinLength.result &&
                     transcriptsWithProteinLength.result.length > 0 &&
                     canonicalTranscriptId;
-                return (React__namespace.createElement("div", { className: classNames__default["default"]('small', styles$1.dropDown) },
+                return (React__namespace.createElement("div", { className: classnames__default["default"]('small', styles$1.dropDown) },
                     this.loadingIndicator(isLoading),
                     !isLoading &&
                         requiredData &&