Removed GopherJS, basic frontend completed, need backend changes for

torrent storage

torrent-project/node_modules/react-bootstrap-table/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 SparkMonitor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

torrent-project/node_modules/react-bootstrap-table/css/react-bootstrap-table.css

@@ -0,0 +1,337 @@
+/*editor error animate*/
+/*@import "~toastr/build/toastr.min.css";*/
+
+.react-bs-table-container .react-bs-table-search-form {
+  margin-bottom: 0;
+}
+
+.react-bs-table-bordered {
+  border: 1px solid #ddd;
+  border-radius: 5px;
+}
+
+.react-bs-table table {
+  margin-bottom: 0;
+  table-layout: fixed;
+}
+
+.react-bs-table table td,
+.react-bs-table table th {
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+}
+
+.react-bs-table-pagination {
+  margin-top: 10px;
+}
+
+.react-bs-table-tool-bar {
+  margin-bottom: 5px;
+}
+
+.react-bs-container-header,
+.react-bs-container-footer {
+  overflow: hidden;
+  width: 100%;
+}
+
+.react-bs-container-body {
+  /*height: 154px;*/
+  overflow: auto;
+  width: 100%;
+}
+
+.react-bootstrap-table-page-btns-ul {
+  float: right;
+  /* override the margin-top defined in .pagination class in bootstrap. */
+  margin-top: 0;
+}
+
+.react-bs-table .table-bordered {
+    border: 0;
+    outline: none !important;
+}
+
+.react-bs-table .table-bordered > thead > tr > th,
+.react-bs-table .table-bordered > thead > tr > td {
+  border-bottom-width: 2px;
+}
+
+.react-bs-table .table-bordered > tbody > tr > td {
+  outline: none !important;
+}
+
+.react-bs-table .table-bordered > tbody > tr > td.default-focus-cell {
+  outline: 3px solid cornflowerblue !important;
+  outline-offset: -1px;
+}
+
+.react-bs-table .table-bordered > tfoot > tr > th,
+.react-bs-table .table-bordered > tfoot > tr > td {
+  border-top-width: 2px;
+}
+
+.react-bs-table .table-bordered > tfoot > tr > th,
+.react-bs-table .table-bordered > tfoot > tr > td {
+  border-bottom-width: 0;
+}
+
+/*Esquerda*/
+.react-bs-table .table-bordered > thead > tr > th:first-child,
+.react-bs-table .table-bordered > tbody > tr > th:first-child,
+.react-bs-table .table-bordered > tfoot > tr > th:first-child,
+.react-bs-table .table-bordered > thead > tr > td:first-child,
+.react-bs-table .table-bordered > tbody > tr > td:first-child,
+.react-bs-table .table-bordered > tfoot > tr > td:first-child {
+  border-left-width: 0;
+}
+
+/*Direita*/
+.react-bs-table .table-bordered > thead > tr > th:last-child,
+.react-bs-table .table-bordered > tbody > tr > th:last-child,
+.react-bs-table .table-bordered > tfoot > tr > th:last-child,
+.react-bs-table .table-bordered > thead > tr > td:last-child,
+.react-bs-table .table-bordered > tbody > tr > td:last-child,
+.react-bs-table .table-bordered > tfoot > tr > td:last-child {
+  border-right-width: 0;
+}
+
+/*Topo*/
+.react-bs-table .table-bordered > thead > tr:first-child > th,
+.react-bs-table .table-bordered > thead > tr:first-child > td {
+  border-top-width: 0;
+}
+
+/*Baixo*/
+.react-bs-table .table-bordered > tfoot > tr:last-child > th,
+.react-bs-table .table-bordered > tfoot > tr:last-child > td {
+  border-bottom-width: 0;
+}
+
+.react-bs-table .react-bs-container-header > table > thead > tr > th,
+.react-bs-table .react-bs-container-footer > table > thead > tr > th {
+  vertical-align: middle;
+}
+
+.react-bs-table .react-bs-container-header > table > thead > tr > th .filter,
+.react-bs-table .react-bs-container-footer > table > thead > tr > th .filter {
+  font-weight: normal;
+}
+
+.react-bs-table .react-bs-container-header > table > thead > tr > th .select-filter option[value=''],
+.react-bs-table .react-bs-container-header > table > thead > tr > th .select-filter.placeholder-selected,
+.react-bs-table .react-bs-container-header > table > thead > tr > th .filter::-webkit-input-placeholder,
+.react-bs-table .react-bs-container-header > table > thead > tr > th .number-filter-input::-webkit-input-placeholder{
+  color: lightgrey;
+  font-style: italic;
+}
+
+.react-bs-table .react-bs-container-footer > table > thead > tr > th .select-filter option[value=''],
+.react-bs-table .react-bs-container-footer > table > thead > tr > th .select-filter.placeholder-selected,
+.react-bs-table .react-bs-container-footer > table > thead > tr > th .filter::-webkit-input-placeholder,
+.react-bs-table .react-bs-container-footer > table > thead > tr > th .number-filter-input::-webkit-input-placeholder{
+  color: lightgrey;
+  font-style: italic;
+}
+
+.react-bs-table .react-bs-container-header > table > thead > tr > th .select-filter.placeholder-selected option:not([value='']),
+.react-bs-table .react-bs-container-footer > table > thead > tr > th .select-filter.placeholder-selected option:not([value='']) {
+  color: initial;
+  font-style: initial;
+}
+
+.react-bs-table .react-bs-container-header > table > thead > tr > th .number-filter,
+.react-bs-table .react-bs-container-header > table > thead > tr > th .date-filter {
+  display: flex;
+}
+
+.react-bs-table .react-bs-container-footer > table > thead > tr > th .number-filter,
+.react-bs-table .react-bs-container-footer > table > thead > tr > th .date-filter {
+  display: flex;
+}
+
+.react-bs-table .react-bs-container-header > table > thead > tr > th .number-filter-input,
+.react-bs-table .react-bs-container-header > table > thead > tr > th .date-filter-input {
+  margin-left: 5px;
+  float: left;
+  width: calc(100% - 67px - 5px);
+}
+
+.react-bs-table .react-bs-container-footer > table > thead > tr > th .number-filter-input,
+.react-bs-table .react-bs-container-footer > table > thead > tr > th .date-filter-input {
+  margin-left: 5px;
+  float: left;
+  width: calc(100% - 67px - 5px);
+}
+
+.react-bs-table .react-bs-container-header > table > thead > tr > th .number-filter-comparator,
+.react-bs-table .react-bs-container-header > table > thead > tr > th .date-filter-comparator {
+  width: 67px;
+  float: left;
+}
+
+.react-bs-table .react-bs-container-footer > table > thead > tr > th .number-filter-comparator,
+.react-bs-table .react-bs-container-footer > table > thead > tr > th .date-filter-comparator {
+  width: 67px;
+  float: left;
+}
+
+.react-bs-table .react-bs-container-header .sort-column {
+  cursor: pointer;
+}
+
+/*inline editor default style*/
+.react-bs-container .form-control.editor{
+  /*width:100%;
+  top:0;
+  left:0;*/
+  /*height: 100%;
+  position: absolute;*/
+}
+
+.react-bs-container  .textarea-save-btn{
+  position: absolute;
+  z-index: 100;
+  right: 0;
+  top: -21px;
+}
+
+.react-bs-table-no-data {
+  text-align: center;
+}
+
+
+.ReactModal__Overlay {
+  -webkit-perspective: 600;
+  perspective: 600;
+  opacity: 0;
+  overflow-x: hidden;
+  overflow-y: auto;
+  background-color: rgba(0, 0, 0, 0.5);
+  z-index: 101;
+}
+
+.ReactModal__Overlay--after-open {
+  opacity: 1;
+  transition: opacity 150ms ease-out;
+}
+
+.ReactModal__Content {
+  -webkit-transform: scale(0.5) rotateX(-30deg);
+  transform: scale(0.5) rotateX(-30deg);
+}
+
+.ReactModal__Content--after-open {
+  -webkit-transform: scale(1) rotateX(0deg);
+  transform: scale(1) rotateX(0deg);
+  transition: all 150ms ease-in;
+}
+
+.ReactModal__Overlay--before-close {
+  opacity: 0;
+}
+
+.ReactModal__Content--before-close {
+  -webkit-transform: scale(0.5) rotateX(30deg);
+  transform: scale(0.5) rotateX(30deg);
+  transition: all 150ms ease-in;
+}
+
+.ReactModal__Content.modal-dialog {
+  border: none;
+  background-color: transparent;
+}
+
+/*error tip style*/
+.animated {
+  animation-fill-mode: both;
+}
+
+.animated.bounceIn,
+.animated.bounceOut{
+  animation-duration: .75s;
+}
+
+.animated.shake{
+  animation-duration: .3s;
+}
+
+td.react-bs-table-expand-cell {
+    cursor: pointer;
+}
+
+@keyframes shake {
+  from, to {
+    transform: translate3d(0, 0, 0);
+  }
+
+  10%,  50%,  90% {
+    transform: translate3d(-10px, 0, 0);
+  }
+
+  30%, 70%{
+    transform: translate3d(10px, 0, 0);
+  }
+}
+
+.shake {
+  animation-name: shake;
+}
+
+@keyframes bounceIn {
+  from, 20%, 40%, 60%, 80%, to {
+    animation-timing-function: cubic-bezier(0.215, 0.610, 0.355, 1.000);
+  }
+
+  0% {
+    opacity: 0;
+    transform: scale3d(.3, .3, .3);
+  }
+
+  20% {
+    transform: scale3d(1.1, 1.1, 1.1);
+  }
+
+  40% {
+    transform: scale3d(.9, .9, .9);
+  }
+
+  60% {
+    opacity: 1;
+    transform: scale3d(1.03, 1.03, 1.03);
+  }
+
+  80% {
+    transform: scale3d(.97, .97, .97);
+  }
+
+  to {
+    opacity: 1;
+    transform: scale3d(1, 1, 1);
+  }
+}
+
+.bounceIn {
+  animation-name: bounceIn;
+}
+
+@keyframes bounceOut {
+  20% {
+    transform: scale3d(.9, .9, .9);
+  }
+
+  50%, 55% {
+    opacity: 1;
+    transform: scale3d(1.1, 1.1, 1.1);
+  }
+
+  to {
+    opacity: 0;
+    transform: scale3d(.3, .3, .3);
+  }
+}
+
+.bounceOut {
+  animation-name: bounceOut;
+}

torrent-project/node_modules/react-bootstrap-table/lib/Const.js

@@ -0,0 +1,100 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var CONST_VAR = {
+  SORT_DESC: 'desc',
+  SORT_ASC: 'asc',
+  AWAIT_BEFORE_CELL_EDIT: 1,
+  SIZE_PER_PAGE: 10,
+  NEXT_PAGE: '>',
+  NEXT_PAGE_TITLE: 'next page',
+  LAST_PAGE: '>>',
+  LAST_PAGE_TITLE: 'last page',
+  PRE_PAGE: '<',
+  PRE_PAGE_TITLE: 'previous page',
+  FIRST_PAGE: '<<',
+  FIRST_PAGE_TITLE: 'first page',
+  PAGE_START_INDEX: 1,
+  ROW_SELECT_BG_COLOR: '',
+  ROW_SELECT_NONE: 'none',
+  ROW_SELECT_SINGLE: 'radio',
+  ROW_SELECT_MULTI: 'checkbox',
+  CELL_EDIT_NONE: 'none',
+  CELL_EDIT_CLICK: 'click',
+  CELL_EDIT_DBCLICK: 'dbclick',
+  SIZE_PER_PAGE_LIST: [10, 25, 30, 50],
+  PAGINATION_SIZE: 5,
+  PAGINATION_POS_TOP: 'top',
+  PAGINATION_POS_BOTTOM: 'bottom',
+  PAGINATION_POS_BOTH: 'both',
+  TOOLBAR_POS_TOP: 'top',
+  TOOLBAR_POS_BOTTOM: 'bottom',
+  TOOLBAR_POS_BOTH: 'both',
+  NO_DATA_TEXT: 'There is no data to display',
+  SHOW_ONLY_SELECT: 'Show Selected Only',
+  SHOW_ALL: 'Show All',
+  EXPORT_CSV_TEXT: 'Export to CSV',
+  INSERT_BTN_TEXT: 'New',
+  DELETE_BTN_TEXT: 'Delete',
+  SAVE_BTN_TEXT: 'Save',
+  CLOSE_BTN_TEXT: 'Close',
+  FILTER_DELAY: 500,
+  SCROLL_TOP: 'Top',
+  SCROLL_BOTTOM: 'Bottom',
+  FILTER_TYPE: {
+    TEXT: 'TextFilter',
+    REGEX: 'RegexFilter',
+    SELECT: 'SelectFilter',
+    NUMBER: 'NumberFilter',
+    DATE: 'DateFilter',
+    CUSTOM: 'CustomFilter',
+    ARRAY: 'ArrayFilter'
+  },
+  FILTER_COND_EQ: 'eq',
+  FILTER_COND_LIKE: 'like',
+  EXPAND_BY_ROW: 'row',
+  EXPAND_BY_COL: 'column',
+  REMOTE_SORT: 'sort',
+  REMOTE_PAGE: 'pagination',
+  REMOTE_CELL_EDIT: 'cellEdit',
+  REMOTE_INSERT_ROW: 'insertRow',
+  REMOTE_DROP_ROW: 'dropRow',
+  REMOTE_FILTER: 'filter',
+  REMOTE_SEARCH: 'search',
+  REMOTE_EXPORT_CSV: 'exportCSV',
+  INSERT_FAIL_INDICATOR: 'Validation errors, please check!',
+  DEFAULT_CSV_SEPARATOR: ',',
+  CSV_STRING_TYPE: 'string',
+  CSV_NUMBER_TYPE: 'number',
+  AUTO_COLLAPSE_WHEN_SORT: false,
+  AUTO_COLLAPSE_WHEN_SEARCH: false,
+  AUTO_COLLAPSE_WHEN_FILTER: false
+};
+
+CONST_VAR.REMOTE = {};
+CONST_VAR.REMOTE[CONST_VAR.REMOTE_SORT] = false;
+CONST_VAR.REMOTE[CONST_VAR.REMOTE_PAGE] = false;
+CONST_VAR.REMOTE[CONST_VAR.REMOTE_CELL_EDIT] = false;
+CONST_VAR.REMOTE[CONST_VAR.REMOTE_INSERT_ROW] = false;
+CONST_VAR.REMOTE[CONST_VAR.REMOTE_DROP_ROW] = false;
+CONST_VAR.REMOTE[CONST_VAR.REMOTE_FILTER] = false;
+CONST_VAR.REMOTE[CONST_VAR.REMOTE_SEARCH] = false;
+CONST_VAR.REMOTE[CONST_VAR.REMOTE_EXPORT_CSV] = false;
+
+var _default = CONST_VAR;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(CONST_VAR, 'CONST_VAR', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/Const.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/Const.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/Editor.js

@@ -0,0 +1,145 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+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 _util = require('./util');
+
+var _util2 = _interopRequireDefault(_util);
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var editor = function editor(editable, attr, format, editorClass, defaultValue, ignoreEditable, row) {
+  if (editable === true || editable === false && ignoreEditable || typeof editable === 'string') {
+    // simple declare
+    var type = editable ? 'text' : editable;
+    return _react2.default.createElement('input', _extends({}, attr, { type: type, defaultValue: defaultValue,
+      className: (editorClass || '') + ' form-control editor edit-text' }));
+  } else if (!editable) {
+    var _type = editable ? 'text' : editable;
+    return _react2.default.createElement('input', _extends({}, attr, { type: _type, defaultValue: defaultValue,
+      disabled: 'disabled',
+      className: (editorClass || '') + ' form-control editor edit-text' }));
+  } else if (editable && (editable.type === undefined || editable.type === null || editable.type.trim() === '')) {
+    var _type2 = editable ? 'text' : editable;
+    return _react2.default.createElement('input', _extends({}, attr, { type: _type2, defaultValue: defaultValue,
+      className: (editorClass || '') + ' form-control editor edit-text' }));
+  } else if (editable.type) {
+    // standard declare
+    // put style if exist
+    editable.style && (attr.style = editable.style);
+    // put class if exist
+    attr.className = (editorClass || '') + ' form-control editor edit-' + editable.type + (editable.className ? ' ' + editable.className : '');
+
+    if (editable.type === 'select') {
+      // process select input
+      var options = [];
+      var values = editable.options.values;
+      var _editable$options = editable.options,
+          textKey = _editable$options.textKey,
+          valueKey = _editable$options.valueKey;
+
+      if (_util2.default.isFunction(values)) {
+        values = values(row);
+      }
+      if (Array.isArray(values)) {
+        // only can use arrray data for options
+        var text = void 0;
+        var value = void 0;
+        options = values.map(function (option, i) {
+          if ((typeof option === 'undefined' ? 'undefined' : _typeof(option)) === 'object') {
+            text = textKey ? option[textKey] : option.text;
+            value = valueKey ? option[valueKey] : option.value;
+          } else {
+            text = format ? format(option) : option;
+            value = option;
+          }
+          return _react2.default.createElement(
+            'option',
+            { key: 'option' + i, value: value },
+            text
+          );
+        });
+      }
+      return _react2.default.createElement(
+        'select',
+        _extends({}, attr, { defaultValue: defaultValue }),
+        options
+      );
+    } else if (editable.type === 'textarea') {
+      // process textarea input
+      // put other if exist
+      editable.cols && (attr.cols = editable.cols);
+      editable.rows && (attr.rows = editable.rows);
+      var saveBtn = void 0;
+      var keyUpHandler = attr.onKeyDown;
+      if (keyUpHandler) {
+        attr.onKeyDown = function (e) {
+          if (e.keyCode !== 13) {
+            // not Pressed ENTER
+            keyUpHandler(e);
+          }
+        };
+        saveBtn = _react2.default.createElement(
+          'button',
+          {
+            className: 'btn btn-info btn-xs textarea-save-btn',
+            onClick: keyUpHandler },
+          'save'
+        );
+      }
+      return _react2.default.createElement(
+        'div',
+        null,
+        _react2.default.createElement('textarea', _extends({}, attr, { defaultValue: defaultValue })),
+        saveBtn
+      );
+    } else if (editable.type === 'checkbox') {
+      var _values = 'true:false';
+      if (editable.options && editable.options.values) {
+        // values = editable.options.values.split(':');
+        _values = editable.options.values;
+      }
+      attr.className = attr.className.replace('form-control', '');
+      attr.className += ' checkbox pull-right';
+
+      var checked = defaultValue && defaultValue.toString() === _values.split(':')[0] ? true : false;
+
+      return _react2.default.createElement('input', _extends({}, attr, { type: 'checkbox',
+        value: _values, defaultChecked: checked }));
+    } else if (editable.type === 'datetime') {
+      return _react2.default.createElement('input', _extends({}, attr, { type: 'datetime-local', defaultValue: defaultValue }));
+    } else {
+      // process other input type. as password,url,email...
+      return _react2.default.createElement('input', _extends({}, attr, { type: editable.type, defaultValue: defaultValue }));
+    }
+  }
+  // default return for other case of editable
+  return _react2.default.createElement('input', _extends({}, attr, { type: 'text',
+    className: (editorClass || '') + ' form-control editor edit-text' }));
+};
+
+var _default = editor;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(editor, 'editor', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/Editor.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/Editor.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/ExpandComponent.js

@@ -0,0 +1,78 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _classnames = require('classnames');
+
+var _classnames2 = _interopRequireDefault(_classnames);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; } /* eslint max-len: 0 */
+/* eslint no-nested-ternary: 0 */
+
+
+var ExpandComponent = function (_Component) {
+  _inherits(ExpandComponent, _Component);
+
+  function ExpandComponent() {
+    _classCallCheck(this, ExpandComponent);
+
+    return _possibleConstructorReturn(this, (ExpandComponent.__proto__ || Object.getPrototypeOf(ExpandComponent)).apply(this, arguments));
+  }
+
+  _createClass(ExpandComponent, [{
+    key: 'render',
+    value: function render() {
+      var className = this.props.className;
+
+      var trCss = {
+        style: {
+          backgroundColor: this.props.bgColor
+        },
+        className: (0, _classnames2.default)(className)
+      };
+      return _react2.default.createElement(
+        'tr',
+        _extends({ hidden: this.props.hidden, width: this.props.width }, trCss),
+        _react2.default.createElement(
+          'td',
+          { colSpan: this.props.colSpan },
+          this.props.children
+        )
+      );
+    }
+  }]);
+
+  return ExpandComponent;
+}(_react.Component);
+
+var _default = ExpandComponent;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(ExpandComponent, 'ExpandComponent', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/ExpandComponent.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/ExpandComponent.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/ExpandRowHeaderColumn.js

@@ -0,0 +1,68 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 ExpandRowHeaderColumn = function (_Component) {
+  _inherits(ExpandRowHeaderColumn, _Component);
+
+  function ExpandRowHeaderColumn() {
+    _classCallCheck(this, ExpandRowHeaderColumn);
+
+    return _possibleConstructorReturn(this, (ExpandRowHeaderColumn.__proto__ || Object.getPrototypeOf(ExpandRowHeaderColumn)).apply(this, arguments));
+  }
+
+  _createClass(ExpandRowHeaderColumn, [{
+    key: 'render',
+    value: function render() {
+      return _react2.default.createElement(
+        'th',
+        { rowSpan: this.props.rowCount, style: { textAlign: 'center' },
+          className: 'react-bs-table-expand-cell',
+          'data-is-only-head': false },
+        this.props.children
+      );
+    }
+  }]);
+
+  return ExpandRowHeaderColumn;
+}(_react.Component);
+
+ExpandRowHeaderColumn.propTypes = {
+  children: _propTypes2.default.node,
+  rowCount: _propTypes2.default.number
+};
+var _default = ExpandRowHeaderColumn;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(ExpandRowHeaderColumn, 'ExpandRowHeaderColumn', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/ExpandRowHeaderColumn.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/ExpandRowHeaderColumn.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/Filter.js

@@ -0,0 +1,84 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Filter = undefined;
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+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; }; }();
+
+var _Const = require('./Const');
+
+var _Const2 = _interopRequireDefault(_Const);
+
+var _events = require('events');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 Filter = exports.Filter = function (_EventEmitter) {
+  _inherits(Filter, _EventEmitter);
+
+  function Filter(data) {
+    _classCallCheck(this, Filter);
+
+    var _this = _possibleConstructorReturn(this, (Filter.__proto__ || Object.getPrototypeOf(Filter)).call(this, data));
+
+    _this.currentFilter = {};
+    return _this;
+  }
+
+  _createClass(Filter, [{
+    key: 'handleFilter',
+    value: function handleFilter(dataField, value, type, filterObj) {
+      var filterType = type || _Const2.default.FILTER_TYPE.CUSTOM;
+
+      var props = {
+        cond: filterObj.condition // Only for select and text filter
+      };
+
+      if (value !== null && (typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object') {
+        // value of the filter is an object
+        var hasValue = true;
+        for (var prop in value) {
+          if (!value[prop] || value[prop] === '') {
+            hasValue = false;
+            break;
+          }
+        }
+        // if one of the object properties is undefined or empty, we remove the filter
+        if (hasValue) {
+          this.currentFilter[dataField] = { value: value, type: filterType, props: props };
+        } else {
+          delete this.currentFilter[dataField];
+        }
+      } else if (!value || value.trim() === '') {
+        delete this.currentFilter[dataField];
+      } else {
+        this.currentFilter[dataField] = { value: value.trim(), type: filterType, props: props };
+      }
+      this.emit('onFilterChange', this.currentFilter);
+    }
+  }]);
+
+  return Filter;
+}(_events.EventEmitter);
+
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(Filter, 'Filter', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/Filter.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/Notification.js

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.notice = undefined;
+
+var _reactSAlert = require('react-s-alert');
+
+var _reactSAlert2 = _interopRequireDefault(_reactSAlert);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var notice = function notice(type, msg, title) {
+  var titleHTML = title ? '<h4><strong>' + title + '</strong></h4>' : '';
+
+  var bodyHTML = '\n    ' + titleHTML + '\n    <div>\n      <span class=\'fa fa-exclamation-triangle glyphicon glyphicon-alert\'></span>&nbsp;\n      <span>' + msg + '</span>\n    </div>\n  ';
+
+  _reactSAlert2.default.error(bodyHTML, {
+    position: 'top-right',
+    timeout: 3000,
+    html: true,
+    effect: 'scale'
+  });
+};
+
+exports.notice = notice;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(notice, 'notice', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/Notification.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/SelectRowHeaderColumn.js

@@ -0,0 +1,67 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 SelectRowHeaderColumn = function (_Component) {
+  _inherits(SelectRowHeaderColumn, _Component);
+
+  function SelectRowHeaderColumn() {
+    _classCallCheck(this, SelectRowHeaderColumn);
+
+    return _possibleConstructorReturn(this, (SelectRowHeaderColumn.__proto__ || Object.getPrototypeOf(SelectRowHeaderColumn)).apply(this, arguments));
+  }
+
+  _createClass(SelectRowHeaderColumn, [{
+    key: 'render',
+    value: function render() {
+      return _react2.default.createElement(
+        'th',
+        { rowSpan: this.props.rowCount, style: { textAlign: 'center' },
+          'data-is-only-head': false },
+        this.props.children
+      );
+    }
+  }]);
+
+  return SelectRowHeaderColumn;
+}(_react.Component);
+
+SelectRowHeaderColumn.propTypes = {
+  children: _propTypes2.default.node,
+  rowCount: _propTypes2.default.number
+};
+var _default = SelectRowHeaderColumn;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(SelectRowHeaderColumn, 'SelectRowHeaderColumn', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/SelectRowHeaderColumn.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/SelectRowHeaderColumn.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/TableBody.js

@@ -0,0 +1,782 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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 _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _util = require('./util');
+
+var _util2 = _interopRequireDefault(_util);
+
+var _Const = require('./Const');
+
+var _Const2 = _interopRequireDefault(_Const);
+
+var _TableRow = require('./TableRow');
+
+var _TableRow2 = _interopRequireDefault(_TableRow);
+
+var _TableColumn = require('./TableColumn');
+
+var _TableColumn2 = _interopRequireDefault(_TableColumn);
+
+var _TableEditColumn = require('./TableEditColumn');
+
+var _TableEditColumn2 = _interopRequireDefault(_TableEditColumn);
+
+var _classnames = require('classnames');
+
+var _classnames2 = _interopRequireDefault(_classnames);
+
+var _ExpandComponent = require('./ExpandComponent');
+
+var _ExpandComponent2 = _interopRequireDefault(_ExpandComponent);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 TableBody = function (_Component) {
+  _inherits(TableBody, _Component);
+
+  function TableBody(props) {
+    _classCallCheck(this, TableBody);
+
+    var _this = _possibleConstructorReturn(this, (TableBody.__proto__ || Object.getPrototypeOf(TableBody)).call(this, props));
+
+    _this.handleCellKeyDown = function () {
+      return _this.__handleCellKeyDown__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.handleRowMouseOut = function () {
+      return _this.__handleRowMouseOut__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.handleRowMouseOver = function () {
+      return _this.__handleRowMouseOver__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.handleRowClick = function () {
+      return _this.__handleRowClick__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.handleRowDoubleClick = function () {
+      return _this.__handleRowDoubleClick__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.handleSelectRow = function () {
+      return _this.__handleSelectRow__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.handleSelectRowColumChange = function () {
+      return _this.__handleSelectRowColumChange__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.handleClickCell = function () {
+      return _this.__handleClickCell__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.handleEditCell = function () {
+      return _this.__handleEditCell__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.nextEditableCell = function () {
+      return _this.__nextEditableCell__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.handleCompleteEditCell = function () {
+      return _this.__handleCompleteEditCell__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.cancelEditCell = function () {
+      return _this.__cancelEditCell__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.handleClickonSelectColumn = function () {
+      return _this.__handleClickonSelectColumn__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.getHeaderColGrouop = function () {
+      return _this.__getHeaderColGrouop__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.state = {
+      currEditCell: null
+    };
+    return _this;
+  }
+
+  _createClass(TableBody, [{
+    key: '__getHeaderColGrouop__REACT_HOT_LOADER__',
+    value: function __getHeaderColGrouop__REACT_HOT_LOADER__() {
+      return this.__getHeaderColGrouop__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__handleClickonSelectColumn__REACT_HOT_LOADER__',
+    value: function __handleClickonSelectColumn__REACT_HOT_LOADER__() {
+      return this.__handleClickonSelectColumn__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__cancelEditCell__REACT_HOT_LOADER__',
+    value: function __cancelEditCell__REACT_HOT_LOADER__() {
+      return this.__cancelEditCell__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__handleCompleteEditCell__REACT_HOT_LOADER__',
+    value: function __handleCompleteEditCell__REACT_HOT_LOADER__() {
+      return this.__handleCompleteEditCell__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__nextEditableCell__REACT_HOT_LOADER__',
+    value: function __nextEditableCell__REACT_HOT_LOADER__() {
+      return this.__nextEditableCell__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__handleEditCell__REACT_HOT_LOADER__',
+    value: function __handleEditCell__REACT_HOT_LOADER__() {
+      return this.__handleEditCell__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__handleClickCell__REACT_HOT_LOADER__',
+    value: function __handleClickCell__REACT_HOT_LOADER__() {
+      return this.__handleClickCell__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__handleSelectRowColumChange__REACT_HOT_LOADER__',
+    value: function __handleSelectRowColumChange__REACT_HOT_LOADER__() {
+      return this.__handleSelectRowColumChange__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__handleSelectRow__REACT_HOT_LOADER__',
+    value: function __handleSelectRow__REACT_HOT_LOADER__() {
+      return this.__handleSelectRow__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__handleRowDoubleClick__REACT_HOT_LOADER__',
+    value: function __handleRowDoubleClick__REACT_HOT_LOADER__() {
+      return this.__handleRowDoubleClick__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__handleRowClick__REACT_HOT_LOADER__',
+    value: function __handleRowClick__REACT_HOT_LOADER__() {
+      return this.__handleRowClick__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__handleRowMouseOver__REACT_HOT_LOADER__',
+    value: function __handleRowMouseOver__REACT_HOT_LOADER__() {
+      return this.__handleRowMouseOver__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__handleRowMouseOut__REACT_HOT_LOADER__',
+    value: function __handleRowMouseOut__REACT_HOT_LOADER__() {
+      return this.__handleRowMouseOut__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__handleCellKeyDown__REACT_HOT_LOADER__',
+    value: function __handleCellKeyDown__REACT_HOT_LOADER__() {
+      return this.__handleCellKeyDown__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      var _props = this.props,
+          cellEdit = _props.cellEdit,
+          beforeShowError = _props.beforeShowError,
+          x = _props.x,
+          y = _props.y,
+          keyBoardNav = _props.keyBoardNav,
+          trStyle = _props.trStyle,
+          version = _props.version;
+
+      var customTableClasses = {
+        'table-striped': this.props.striped,
+        'table-bordered': this.props.bordered,
+        'table-hover': this.props.hover
+      };
+      if (this.props.condensed) {
+        if (_util2.default.isBootstrap4(version)) customTableClasses['table-sm'] = true;else customTableClasses['table-condensed'] = true;
+      }
+      var tableClasses = (0, _classnames2.default)('table', customTableClasses, this.props.tableBodyClass);
+
+      var noneditableRows = cellEdit.nonEditableRows && cellEdit.nonEditableRows() || [];
+      var unselectable = this.props.selectRow.unselectable || [];
+      var isSelectRowDefined = _util2.default.isSelectRowDefined(this.props.selectRow.mode);
+      var tableHeader = _util2.default.renderColGroup(this.props.columns, this.props.selectRow, this.props.expandColumnOptions, version);
+      var inputType = this.props.selectRow.mode === _Const2.default.ROW_SELECT_SINGLE ? 'radio' : 'checkbox';
+      var CustomComponent = this.props.selectRow.customComponent;
+      var enableKeyBoardNav = keyBoardNav === true || (typeof keyBoardNav === 'undefined' ? 'undefined' : _typeof(keyBoardNav)) === 'object';
+      var customEditAndNavStyle = (typeof keyBoardNav === 'undefined' ? 'undefined' : _typeof(keyBoardNav)) === 'object' ? keyBoardNav.customStyleOnEditCell : null;
+      var customNavStyle = (typeof keyBoardNav === 'undefined' ? 'undefined' : _typeof(keyBoardNav)) === 'object' ? keyBoardNav.customStyle : null;
+      var ExpandColumnCustomComponent = this.props.expandColumnOptions.expandColumnComponent;
+      var expandColSpan = this.props.columns.filter(function (col) {
+        return col && !col.hidden;
+      }).length;
+      if (isSelectRowDefined && !this.props.selectRow.hideSelectColumn) {
+        expandColSpan += 1;
+      }
+      var tabIndex = 1;
+      if (this.props.expandColumnOptions.expandColumnVisible) {
+        expandColSpan += 1;
+      }
+
+      var tableRows = this.props.data.map(function (data, r) {
+        var tableColumns = this.props.columns.filter(function (_) {
+          return _ != null;
+        }).map(function (column, i) {
+          var fieldValue = data[column.name];
+          var isFocusCell = r === y && i === x;
+          if (column.name !== this.props.keyField && // Key field can't be edit
+          column.editable && // column is editable? default is true, user can set it false
+          column.editable.readOnly !== true && this.state.currEditCell !== null && this.state.currEditCell.rid === r && this.state.currEditCell.cid === i && noneditableRows.indexOf(data[this.props.keyField]) === -1) {
+            var editable = column.editable;
+            var format = column.format ? function (value) {
+              return column.format(value, data, column.formatExtraData, r).replace(/<.*?>/g, '');
+            } : false;
+            if (_util2.default.isFunction(column.editable)) {
+              editable = column.editable(fieldValue, data, r, i);
+            }
+
+            return _react2.default.createElement(_TableEditColumn2.default, {
+              completeEdit: this.handleCompleteEditCell
+              // add by bluespring for column editor customize
+              , editable: editable,
+              attrs: column.editAttrs,
+              customEditor: column.customEditor,
+              format: column.format ? format : false,
+              key: i,
+              blurToSave: cellEdit.blurToSave,
+              blurToEscape: cellEdit.blurToEscape,
+              onTab: this.handleEditCell,
+              rowIndex: r,
+              colIndex: i,
+              row: data,
+              fieldValue: fieldValue,
+              className: column.editClassName,
+              invalidColumnClassName: column.invalidEditColumnClassName,
+              beforeShowError: beforeShowError,
+              isFocus: isFocusCell,
+              customStyleWithNav: customEditAndNavStyle });
+          } else {
+            // add by bluespring for className customize
+            var formattedValue = void 0;
+            var columnChild = fieldValue && fieldValue.toString();
+            var columnTitle = null;
+            var tdClassName = column.className;
+            var tdStyles = column.style;
+            if (_util2.default.isFunction(column.className)) {
+              tdClassName = column.className(fieldValue, data, r, i);
+            }
+
+            if (_util2.default.isFunction(column.style)) {
+              tdStyles = column.style(fieldValue, data, r, i);
+            }
+
+            if (typeof column.format !== 'undefined') {
+              formattedValue = column.format(fieldValue, data, column.formatExtraData, r);
+              if (!_react2.default.isValidElement(formattedValue)) {
+                columnChild = _react2.default.createElement('div', { dangerouslySetInnerHTML: { __html: formattedValue } });
+              } else {
+                columnChild = formattedValue;
+              }
+            }
+            if (_util2.default.isFunction(column.columnTitle)) {
+              columnTitle = column.columnTitle(fieldValue, data, r, i);
+            } else if (typeof column.columnTitle === 'string') {
+              columnTitle = column.columnTitle;
+            } else if (column.columnTitle) {
+              if (formattedValue) columnTitle = formattedValue.toString();else if (fieldValue) columnTitle = fieldValue.toString();
+            }
+            return _react2.default.createElement(
+              _TableColumn2.default,
+              { key: i,
+                cIndex: i,
+                rIndex: r,
+                dataAlign: column.align,
+                className: tdClassName,
+                columnTitle: columnTitle,
+                cellEdit: cellEdit,
+                hidden: column.hidden,
+                onEdit: this.handleEditCell,
+                width: column.width,
+                onClick: this.handleClickCell,
+                attrs: column.attrs,
+                style: tdStyles,
+                tabIndex: tabIndex++ + '',
+                isFocus: isFocusCell,
+                keyBoardNav: enableKeyBoardNav,
+                onKeyDown: this.handleCellKeyDown,
+                customNavStyle: customNavStyle,
+                row: data,
+                withoutTabIndex: this.props.withoutTabIndex },
+              columnChild
+            );
+          }
+        }, this);
+        var key = data[this.props.keyField];
+        var disable = unselectable.indexOf(key) !== -1;
+        var selected = this.props.selectedRowKeys.indexOf(key) !== -1;
+        var selectRowColumn = isSelectRowDefined && !this.props.selectRow.hideSelectColumn ? this.renderSelectRowColumn(selected, inputType, disable, CustomComponent, r, data) : null;
+        var expandedRowColumn = this.renderExpandRowColumn(this.props.expandableRow && this.props.expandableRow(data), this.props.expanding.indexOf(key) > -1, ExpandColumnCustomComponent, r);
+        var haveExpandContent = this.props.expandableRow && this.props.expandableRow(data);
+        var isExpanding = haveExpandContent && this.props.expanding.indexOf(key) > -1;
+
+        // add by bluespring for className customize
+        var trClassName = this.props.trClassName;
+        if (_util2.default.isFunction(this.props.trClassName)) {
+          trClassName = this.props.trClassName(data, r);
+        }
+        if (isExpanding && this.props.expandParentClass) {
+          trClassName += _util2.default.isFunction(this.props.expandParentClass) ? this.props.expandParentClass(data, r) : this.props.expandParentClass;
+        }
+        var result = [_react2.default.createElement(
+          _TableRow2.default,
+          { isSelected: selected, key: key, className: trClassName,
+            index: r,
+            row: data,
+            selectRow: isSelectRowDefined ? this.props.selectRow : undefined,
+            enableCellEdit: cellEdit.mode !== _Const2.default.CELL_EDIT_NONE,
+            onRowClick: this.handleRowClick,
+            onRowDoubleClick: this.handleRowDoubleClick,
+            onRowMouseOver: this.handleRowMouseOver,
+            onRowMouseOut: this.handleRowMouseOut,
+            onSelectRow: this.handleSelectRow,
+            onExpandRow: this.handleClickCell,
+            unselectableRow: disable,
+            style: trStyle,
+            dbClickToEdit: cellEdit.mode === _Const2.default.CELL_EDIT_DBCLICK },
+          this.props.expandColumnOptions.expandColumnVisible && this.props.expandColumnOptions.expandColumnBeforeSelectColumn && expandedRowColumn,
+          selectRowColumn,
+          this.props.expandColumnOptions.expandColumnVisible && !this.props.expandColumnOptions.expandColumnBeforeSelectColumn && expandedRowColumn,
+          tableColumns
+        )];
+
+        if (haveExpandContent) {
+          var expandBodyClass = _util2.default.isFunction(this.props.expandBodyClass) ? this.props.expandBodyClass(data, r, isExpanding) : this.props.expandBodyClass;
+          result.push(_react2.default.createElement(
+            _ExpandComponent2.default,
+            {
+              key: key + '-expand',
+              row: data,
+              className: expandBodyClass,
+              bgColor: this.props.expandRowBgColor || this.props.selectRow.bgColor || undefined,
+              hidden: !isExpanding,
+              colSpan: expandColSpan,
+              width: "100%" },
+            this.props.expandComponent(data)
+          ));
+        }
+        return result;
+      }, this);
+
+      if (tableRows.length === 0 && !this.props.withoutNoDataText) {
+        var colSpan = this.props.columns.filter(function (c) {
+          return !c.hidden;
+        }).length + (isSelectRowDefined && !this.props.selectRow.hideSelectColumn ? 1 : 0) + (this.props.expandColumnOptions.expandColumnVisible ? 1 : 0);
+        tableRows = [_react2.default.createElement(
+          _TableRow2.default,
+          { key: '##table-empty##', style: trStyle },
+          _react2.default.createElement(
+            'td',
+            { 'data-toggle': 'collapse',
+              colSpan: colSpan,
+              className: 'react-bs-table-no-data' },
+            this.props.noDataText || _Const2.default.NO_DATA_TEXT
+          )
+        )];
+      }
+
+      return _react2.default.createElement(
+        'div',
+        { ref: 'container',
+          className: (0, _classnames2.default)('react-bs-container-body', this.props.bodyContainerClass),
+          style: this.props.style },
+        _react2.default.createElement(
+          'table',
+          { className: tableClasses },
+          _react2.default.cloneElement(tableHeader, { ref: 'header' }),
+          _react2.default.createElement(
+            'tbody',
+            { ref: 'tbody' },
+            tableRows
+          )
+        )
+      );
+    }
+  }, {
+    key: '__handleCellKeyDown__REACT_HOT_LOADER__',
+    value: function __handleCellKeyDown__REACT_HOT_LOADER__(e, lastEditCell) {
+      e.preventDefault();
+      var _props2 = this.props,
+          keyBoardNav = _props2.keyBoardNav,
+          onNavigateCell = _props2.onNavigateCell,
+          cellEdit = _props2.cellEdit;
+
+      var offset = void 0;
+      if (e.keyCode === 37) {
+        offset = { x: -1, y: 0 };
+      } else if (e.keyCode === 38) {
+        offset = { x: 0, y: -1 };
+      } else if (e.keyCode === 39 || e.keyCode === 9) {
+        offset = { x: 1, y: 0 };
+        if (e.keyCode === 9 && lastEditCell) {
+          offset = _extends({}, offset, {
+            lastEditCell: lastEditCell
+          });
+        }
+      } else if (e.keyCode === 40) {
+        offset = { x: 0, y: 1 };
+      } else if (e.keyCode === 13) {
+        var enterToEdit = (typeof keyBoardNav === 'undefined' ? 'undefined' : _typeof(keyBoardNav)) === 'object' ? keyBoardNav.enterToEdit : false;
+        var enterToExpand = (typeof keyBoardNav === 'undefined' ? 'undefined' : _typeof(keyBoardNav)) === 'object' ? keyBoardNav.enterToExpand : false;
+
+        if (cellEdit && enterToEdit) {
+          this.handleEditCell(e.target.parentElement.rowIndex + 1, e.currentTarget.cellIndex, '', e);
+        }
+
+        if (enterToExpand) {
+          this.handleClickCell(this.props.y + 1, this.props.x);
+        }
+      }
+      if (offset && keyBoardNav) {
+        onNavigateCell(offset);
+      }
+    }
+  }, {
+    key: '__handleRowMouseOut__REACT_HOT_LOADER__',
+    value: function __handleRowMouseOut__REACT_HOT_LOADER__(rowIndex, event) {
+      var targetRow = this.props.data[rowIndex];
+      this.props.onRowMouseOut(targetRow, event);
+    }
+  }, {
+    key: '__handleRowMouseOver__REACT_HOT_LOADER__',
+    value: function __handleRowMouseOver__REACT_HOT_LOADER__(rowIndex, event) {
+      var targetRow = this.props.data[rowIndex];
+      this.props.onRowMouseOver(targetRow, event);
+    }
+  }, {
+    key: '__handleRowClick__REACT_HOT_LOADER__',
+    value: function __handleRowClick__REACT_HOT_LOADER__(rowIndex, cellIndex) {
+      var _props3 = this.props,
+          onRowClick = _props3.onRowClick,
+          selectRow = _props3.selectRow;
+
+      if (_util2.default.isSelectRowDefined(selectRow.mode)) cellIndex--;
+      if (this._isExpandColumnVisible()) cellIndex--;
+      onRowClick(this.props.data[rowIndex - 1], rowIndex - 1, cellIndex);
+    }
+  }, {
+    key: '__handleRowDoubleClick__REACT_HOT_LOADER__',
+    value: function __handleRowDoubleClick__REACT_HOT_LOADER__(rowIndex) {
+      var onRowDoubleClick = this.props.onRowDoubleClick;
+
+      var targetRow = this.props.data[rowIndex];
+      onRowDoubleClick(targetRow);
+    }
+  }, {
+    key: '__handleSelectRow__REACT_HOT_LOADER__',
+    value: function __handleSelectRow__REACT_HOT_LOADER__(rowIndex, isSelected, e) {
+      var selectedRow = void 0;
+      var _props4 = this.props,
+          data = _props4.data,
+          onSelectRow = _props4.onSelectRow;
+
+      data.forEach(function (row, i) {
+        if (i === rowIndex - 1) {
+          selectedRow = row;
+          return false;
+        }
+      });
+      onSelectRow(selectedRow, isSelected, e, rowIndex - 1);
+    }
+  }, {
+    key: '__handleSelectRowColumChange__REACT_HOT_LOADER__',
+    value: function __handleSelectRowColumChange__REACT_HOT_LOADER__(e, rowIndex) {
+      if (!this.props.selectRow.clickToSelect || !this.props.selectRow.clickToSelectAndEditCell) {
+        this.handleSelectRow(rowIndex + 1, e.currentTarget.checked, e);
+      }
+    }
+  }, {
+    key: '__handleClickCell__REACT_HOT_LOADER__',
+    value: function __handleClickCell__REACT_HOT_LOADER__(rowIndex) {
+      var columnIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -1;
+      var _props5 = this.props,
+          columns = _props5.columns,
+          keyField = _props5.keyField,
+          expandBy = _props5.expandBy,
+          expandableRow = _props5.expandableRow,
+          _props5$selectRow = _props5.selectRow,
+          mode = _props5$selectRow.mode,
+          clickToExpand = _props5$selectRow.clickToExpand,
+          hideSelectColumn = _props5$selectRow.hideSelectColumn,
+          onlyOneExpanding = _props5.onlyOneExpanding;
+
+      var isSelectRowDefined = _util2.default.isSelectRowDefined(mode);
+      var selectRowAndExpand = isSelectRowDefined && !clickToExpand ? false : true;
+      columnIndex = isSelectRowDefined && !hideSelectColumn ? columnIndex - 1 : columnIndex;
+      columnIndex = this._isExpandColumnVisible() ? columnIndex - 1 : columnIndex;
+      if (expandableRow && selectRowAndExpand && (expandBy === _Const2.default.EXPAND_BY_ROW ||
+      /* Below will allow expanding trigger by clicking on selection column
+      if configure as expanding by column */
+      expandBy === _Const2.default.EXPAND_BY_COL && columnIndex < 0 || expandBy === _Const2.default.EXPAND_BY_COL && columns[columnIndex].expandable)) {
+        var expanding = this.props.expanding;
+        var rowKey = this.props.data[rowIndex - 1][keyField];
+        var isRowExpanding = expanding.indexOf(rowKey) > -1;
+
+        if (isRowExpanding) {
+          // collapse
+          expanding = expanding.filter(function (k) {
+            return k !== rowKey;
+          });
+        } else {
+          // expand
+          if (onlyOneExpanding) expanding = [rowKey];else expanding.push(rowKey);
+        }
+        this.props.onExpand(expanding, rowKey, isRowExpanding);
+      }
+    }
+  }, {
+    key: '__handleEditCell__REACT_HOT_LOADER__',
+    value: function __handleEditCell__REACT_HOT_LOADER__(rowIndex, columnIndex, action, e) {
+      var selectRow = this.props.selectRow;
+
+      var defineSelectRow = _util2.default.isSelectRowDefined(selectRow.mode);
+      var expandColumnVisible = this._isExpandColumnVisible();
+      if (defineSelectRow) {
+        columnIndex--;
+        if (selectRow.hideSelectColumn) columnIndex++;
+      }
+      if (expandColumnVisible) {
+        columnIndex--;
+      }
+      rowIndex--;
+
+      if (action === 'tab') {
+        if (defineSelectRow && !selectRow.hideSelectColumn) columnIndex++;
+        if (expandColumnVisible) columnIndex++;
+        this.handleCompleteEditCell(e.target.value, rowIndex, columnIndex - 1);
+        if (columnIndex >= this.props.columns.length) {
+          this.handleCellKeyDown(e, true);
+        } else {
+          this.handleCellKeyDown(e);
+        }
+
+        var _nextEditableCell = this.nextEditableCell(rowIndex, columnIndex),
+            nextRIndex = _nextEditableCell.nextRIndex,
+            nextCIndex = _nextEditableCell.nextCIndex;
+
+        rowIndex = nextRIndex;
+        columnIndex = nextCIndex;
+      }
+
+      var stateObj = {
+        currEditCell: {
+          rid: rowIndex,
+          cid: columnIndex
+        }
+      };
+
+      if (this.props.selectRow.clickToSelectAndEditCell && this.props.cellEdit.mode !== _Const2.default.CELL_EDIT_DBCLICK) {
+        var selected = this.props.selectedRowKeys.indexOf(this.props.data[rowIndex][this.props.keyField]) !== -1;
+        this.handleSelectRow(rowIndex + 1, !selected, e);
+      }
+      this.setState(function () {
+        return stateObj;
+      });
+    }
+  }, {
+    key: '__nextEditableCell__REACT_HOT_LOADER__',
+    value: function __nextEditableCell__REACT_HOT_LOADER__(rIndex, cIndex) {
+      var keyField = this.props.keyField;
+
+      var nextRIndex = rIndex;
+      var nextCIndex = cIndex;
+      var row = void 0;
+      var column = void 0;
+      do {
+        if (nextCIndex >= this.props.columns.length) {
+          nextRIndex++;
+          nextCIndex = 0;
+        }
+        row = this.props.data[nextRIndex];
+        column = this.props.columns[nextCIndex];
+        if (!row) break;
+        var editable = column.editable;
+        if (_util2.default.isFunction(column.editable)) {
+          editable = column.editable(column, row, nextRIndex, nextCIndex);
+        }
+        if (editable && editable.readOnly !== true && !column.hidden && keyField !== column.name) {
+          break;
+        } else {
+          nextCIndex++;
+        }
+      } while (row);
+      return { nextRIndex: nextRIndex, nextCIndex: nextCIndex };
+    }
+  }, {
+    key: '__handleCompleteEditCell__REACT_HOT_LOADER__',
+    value: function __handleCompleteEditCell__REACT_HOT_LOADER__(newVal, rowIndex, columnIndex) {
+      if (newVal !== null) {
+        var result = this.props.onEditCell(newVal, rowIndex, columnIndex);
+        if (result !== _Const2.default.AWAIT_BEFORE_CELL_EDIT) {
+          this.setState(function () {
+            return { currEditCell: null };
+          });
+        }
+      } else {
+        this.setState(function () {
+          return { currEditCell: null };
+        });
+      }
+    }
+  }, {
+    key: '__cancelEditCell__REACT_HOT_LOADER__',
+    value: function __cancelEditCell__REACT_HOT_LOADER__() {
+      this.setState(function () {
+        return { currEditCell: null };
+      });
+    }
+  }, {
+    key: '__handleClickonSelectColumn__REACT_HOT_LOADER__',
+    value: function __handleClickonSelectColumn__REACT_HOT_LOADER__(e, isSelect, rowIndex, row) {
+      e.stopPropagation();
+      if (e.target.tagName === 'TD' && (this.props.selectRow.clickToSelect || this.props.selectRow.clickToSelectAndEditCell)) {
+        var unselectable = this.props.selectRow.unselectable || [];
+        if (unselectable.indexOf(row[this.props.keyField]) === -1) {
+          this.handleSelectRow(rowIndex + 1, isSelect, e);
+          this.handleClickCell(rowIndex + 1);
+        }
+      }
+    }
+  }, {
+    key: 'renderSelectRowColumn',
+    value: function renderSelectRowColumn(selected, inputType, disabled) {
+      var CustomComponent = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+
+      var _this2 = this;
+
+      var rowIndex = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
+      var row = arguments[5];
+
+      return _react2.default.createElement(
+        'td',
+        { onClick: function onClick(e) {
+            _this2.handleClickonSelectColumn(e, !selected, rowIndex, row);
+          }, style: { textAlign: 'center' } },
+        CustomComponent ? _react2.default.createElement(CustomComponent, { type: inputType, checked: selected, disabled: disabled,
+          rowIndex: rowIndex,
+          onChange: function onChange(e) {
+            return _this2.handleSelectRowColumChange(e, rowIndex);
+          } }) : _react2.default.createElement('input', { type: inputType, checked: selected, disabled: disabled,
+          onChange: function onChange(e) {
+            return _this2.handleSelectRowColumChange(e, rowIndex);
+          } })
+      );
+    }
+  }, {
+    key: 'renderExpandRowColumn',
+    value: function renderExpandRowColumn(isExpandableRow, isExpanded, CustomComponent) {
+      var _this3 = this;
+
+      var rowIndex = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+
+      var content = null;
+      if (CustomComponent) {
+        content = _react2.default.createElement(CustomComponent, { isExpandableRow: isExpandableRow, isExpanded: isExpanded });
+      } else if (isExpandableRow) {
+        content = isExpanded ? _react2.default.createElement('span', { className: 'fa fa-minus glyphicon glyphicon-minus' }) : _react2.default.createElement('span', { className: 'fa fa-plus glyphicon glyphicon-plus' });
+      } else {
+        content = ' ';
+      }
+
+      return _react2.default.createElement(
+        'td',
+        {
+          className: 'react-bs-table-expand-cell',
+          onClick: function onClick() {
+            return _this3.handleClickCell(rowIndex + 1);
+          } },
+        content
+      );
+    }
+  }, {
+    key: '_isExpandColumnVisible',
+    value: function _isExpandColumnVisible() {
+      return this.props.expandColumnOptions.expandColumnVisible;
+    }
+  }, {
+    key: '__getHeaderColGrouop__REACT_HOT_LOADER__',
+    value: function __getHeaderColGrouop__REACT_HOT_LOADER__() {
+      return this.refs.header.childNodes;
+    }
+  }]);
+
+  return TableBody;
+}(_react.Component);
+
+TableBody.propTypes = {
+  version: _propTypes2.default.string,
+  data: _propTypes2.default.array,
+  columns: _propTypes2.default.array,
+  striped: _propTypes2.default.bool,
+  bordered: _propTypes2.default.bool,
+  hover: _propTypes2.default.bool,
+  condensed: _propTypes2.default.bool,
+  keyField: _propTypes2.default.string,
+  selectedRowKeys: _propTypes2.default.array,
+  onRowClick: _propTypes2.default.func,
+  onRowDoubleClick: _propTypes2.default.func,
+  onSelectRow: _propTypes2.default.func,
+  noDataText: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.object]),
+  withoutNoDataText: _propTypes2.default.bool,
+  style: _propTypes2.default.object,
+  tableBodyClass: _propTypes2.default.string,
+  bodyContainerClass: _propTypes2.default.string,
+  expandableRow: _propTypes2.default.func,
+  expandComponent: _propTypes2.default.func,
+  expandRowBgColor: _propTypes2.default.string,
+  expandBy: _propTypes2.default.string,
+  expanding: _propTypes2.default.array,
+  onExpand: _propTypes2.default.func,
+  expandBodyClass: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.func]),
+  expandParentClass: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.func]),
+  onlyOneExpanding: _propTypes2.default.bool,
+  beforeShowError: _propTypes2.default.func,
+  keyBoardNav: _propTypes2.default.oneOfType([_propTypes2.default.bool, _propTypes2.default.object]),
+  x: _propTypes2.default.number,
+  y: _propTypes2.default.number,
+  onNavigateCell: _propTypes2.default.func,
+  withoutTabIndex: _propTypes2.default.bool
+};
+var _default = TableBody;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(TableBody, 'TableBody', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/TableBody.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/TableBody.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/TableColumn.js

@@ -0,0 +1,275 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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 _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _reactDom = require('react-dom');
+
+var _reactDom2 = _interopRequireDefault(_reactDom);
+
+var _Const = require('./Const');
+
+var _Const2 = _interopRequireDefault(_Const);
+
+var _util = require('./util');
+
+var _util2 = _interopRequireDefault(_util);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 TableColumn = function (_Component) {
+  _inherits(TableColumn, _Component);
+
+  function TableColumn(props) {
+    _classCallCheck(this, TableColumn);
+
+    var _this = _possibleConstructorReturn(this, (TableColumn.__proto__ || Object.getPrototypeOf(TableColumn)).call(this, props));
+
+    _this.handleCellEdit = function () {
+      return _this.__handleCellEdit__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.handleCellClick = function () {
+      return _this.__handleCellClick__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.handleKeyDown = function () {
+      return _this.__handleKeyDown__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    return _this;
+  }
+  /* eslint no-unused-vars: [0, { "args": "after-used" }] */
+
+
+  _createClass(TableColumn, [{
+    key: '__handleKeyDown__REACT_HOT_LOADER__',
+    value: function __handleKeyDown__REACT_HOT_LOADER__() {
+      return this.__handleKeyDown__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__handleCellClick__REACT_HOT_LOADER__',
+    value: function __handleCellClick__REACT_HOT_LOADER__() {
+      return this.__handleCellClick__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__handleCellEdit__REACT_HOT_LOADER__',
+    value: function __handleCellEdit__REACT_HOT_LOADER__() {
+      return this.__handleCellEdit__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: 'shouldComponentUpdate',
+    value: function shouldComponentUpdate(nextProps, nextState) {
+      var children = this.props.children;
+
+      var shouldUpdated = this.props.width !== nextProps.width || this.props.className !== nextProps.className || this.props.hidden !== nextProps.hidden || this.props.dataAlign !== nextProps.dataAlign || this.props.isFocus !== nextProps.isFocus || (typeof children === 'undefined' ? 'undefined' : _typeof(children)) !== _typeof(nextProps.children) || ('' + this.props.onEdit).toString() !== ('' + nextProps.onEdit).toString();
+
+      if (shouldUpdated) {
+        return shouldUpdated;
+      }
+
+      if ((typeof children === 'undefined' ? 'undefined' : _typeof(children)) === 'object' && children !== null && children.props !== null) {
+        if (children.props.type === 'checkbox' || children.props.type === 'radio') {
+          shouldUpdated = shouldUpdated || children.props.type !== nextProps.children.props.type || children.props.checked !== nextProps.children.props.checked || children.props.disabled !== nextProps.children.props.disabled;
+        } else {
+          shouldUpdated = true;
+        }
+      } else {
+        shouldUpdated = shouldUpdated || children !== nextProps.children;
+      }
+
+      if (shouldUpdated) {
+        return shouldUpdated;
+      }
+
+      if (!(this.props.cellEdit && nextProps.cellEdit)) {
+        return false;
+      } else {
+        return shouldUpdated || this.props.cellEdit.mode !== nextProps.cellEdit.mode;
+      }
+    }
+  }, {
+    key: 'componentDidMount',
+    value: function componentDidMount() {
+      var dom = _reactDom2.default.findDOMNode(this);
+      if (this.props.isFocus) {
+        dom.focus();
+      } else {
+        dom.blur();
+      }
+    }
+  }, {
+    key: 'componentDidUpdate',
+    value: function componentDidUpdate() {
+      var dom = _reactDom2.default.findDOMNode(this);
+      if (this.props.isFocus) {
+        dom.focus();
+      } else {
+        dom.blur();
+      }
+    }
+  }, {
+    key: '__handleCellEdit__REACT_HOT_LOADER__',
+    value: function __handleCellEdit__REACT_HOT_LOADER__(e) {
+      try {
+        if (this.props.cellEdit.mode === _Const2.default.CELL_EDIT_DBCLICK) {
+          if (document.selection && document.selection.empty) {
+            document.selection.empty();
+          } else if (window.getSelection) {
+            var sel = window.getSelection();
+            sel.removeAllRanges();
+          }
+        }
+      } catch (err) {} /* eslint no-empty: 0 */
+      this.props.onEdit(this.props.rIndex + 1, e.currentTarget.cellIndex, e);
+      if (this.props.cellEdit.mode !== _Const2.default.CELL_EDIT_DBCLICK) {
+        this.props.onClick(this.props.rIndex + 1, e.currentTarget.cellIndex, e);
+      }
+    }
+  }, {
+    key: '__handleCellClick__REACT_HOT_LOADER__',
+    value: function __handleCellClick__REACT_HOT_LOADER__(e) {
+      var _props = this.props,
+          onClick = _props.onClick,
+          rIndex = _props.rIndex;
+
+      if (onClick) {
+        onClick(rIndex + 1, e.currentTarget.cellIndex, e);
+      }
+    }
+  }, {
+    key: '__handleKeyDown__REACT_HOT_LOADER__',
+    value: function __handleKeyDown__REACT_HOT_LOADER__(e) {
+      if (this.props.keyBoardNav) {
+        this.props.onKeyDown(e);
+      }
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      var _props2 = this.props,
+          children = _props2.children,
+          columnTitle = _props2.columnTitle,
+          dataAlign = _props2.dataAlign,
+          hidden = _props2.hidden,
+          cellEdit = _props2.cellEdit,
+          attrs = _props2.attrs,
+          style = _props2.style,
+          isFocus = _props2.isFocus,
+          keyBoardNav = _props2.keyBoardNav,
+          tabIndex = _props2.tabIndex,
+          customNavStyle = _props2.customNavStyle,
+          withoutTabIndex = _props2.withoutTabIndex,
+          row = _props2.row;
+      var className = this.props.className;
+
+
+      var tdStyle = _extends({
+        textAlign: dataAlign,
+        display: hidden ? 'none' : null
+      }, style);
+
+      var opts = {};
+
+      if (cellEdit) {
+        if (cellEdit.mode === _Const2.default.CELL_EDIT_CLICK) {
+          opts.onClick = this.handleCellEdit;
+        } else if (cellEdit.mode === _Const2.default.CELL_EDIT_DBCLICK) {
+          opts.onDoubleClick = this.handleCellEdit;
+        } else {
+          opts.onClick = this.handleCellClick;
+        }
+      }
+
+      if (keyBoardNav && isFocus) {
+        opts.onKeyDown = this.handleKeyDown;
+      }
+
+      if (isFocus) {
+        if (customNavStyle) {
+          var cusmtStyle = _util2.default.isFunction(customNavStyle) ? customNavStyle(children, row) : customNavStyle;
+          tdStyle = _extends({}, tdStyle, cusmtStyle);
+        } else {
+          className = className + ' default-focus-cell';
+        }
+      }
+
+      var attr = {};
+      if (!withoutTabIndex) attr.tabIndex = tabIndex;
+      return _react2.default.createElement(
+        'td',
+        _extends({}, attr, { style: tdStyle,
+          title: columnTitle,
+          className: className
+        }, opts, attrs),
+        typeof children === 'boolean' ? children.toString() : children
+      );
+    }
+  }]);
+
+  return TableColumn;
+}(_react.Component);
+
+TableColumn.propTypes = {
+  rIndex: _propTypes2.default.number,
+  dataAlign: _propTypes2.default.string,
+  hidden: _propTypes2.default.bool,
+  className: _propTypes2.default.string,
+  columnTitle: _propTypes2.default.string,
+  children: _propTypes2.default.node,
+  onClick: _propTypes2.default.func,
+  attrs: _propTypes2.default.object,
+  style: _propTypes2.default.object,
+  isFocus: _propTypes2.default.bool,
+  onKeyDown: _propTypes2.default.func,
+  tabIndex: _propTypes2.default.string,
+  withoutTabIndex: _propTypes2.default.bool,
+  keyBoardNav: _propTypes2.default.oneOfType([_propTypes2.default.bool, _propTypes2.default.object]),
+  customNavStyle: _propTypes2.default.oneOfType([_propTypes2.default.func, _propTypes2.default.object]),
+  row: _propTypes2.default.any /* only used on custom styling for navigation */
+};
+
+TableColumn.defaultProps = {
+  dataAlign: 'left',
+  withoutTabIndex: false,
+  hidden: false,
+  className: '',
+  isFocus: false,
+  keyBoardNav: false
+};
+var _default = TableColumn;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(TableColumn, 'TableColumn', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/TableColumn.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/TableColumn.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/TableEditColumn.js

@@ -0,0 +1,451 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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 _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _reactDom = require('react-dom');
+
+var _reactDom2 = _interopRequireDefault(_reactDom);
+
+var _Editor = require('./Editor');
+
+var _Editor2 = _interopRequireDefault(_Editor);
+
+var _Notification = require('./Notification.js');
+
+var _classnames = require('classnames');
+
+var _classnames2 = _interopRequireDefault(_classnames);
+
+var _util = require('./util');
+
+var _util2 = _interopRequireDefault(_util);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 TableEditColumn = function (_Component) {
+  _inherits(TableEditColumn, _Component);
+
+  function TableEditColumn(props) {
+    _classCallCheck(this, TableEditColumn);
+
+    var _this = _possibleConstructorReturn(this, (TableEditColumn.__proto__ || Object.getPrototypeOf(TableEditColumn)).call(this, props));
+
+    _this.handleKeyPress = function () {
+      return _this.__handleKeyPress__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.handleBlur = function () {
+      return _this.__handleBlur__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.handleCustomUpdate = function () {
+      return _this.__handleCustomUpdate__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.notifyToastr = function () {
+      return _this.__notifyToastr__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.handleClick = function () {
+      return _this.__handleClick__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.getInputRef = function () {
+      return _this.__getInputRef__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.getHandleKeyPress = function () {
+      return _this.__getHandleKeyPress__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.getHandleBlur = function () {
+      return _this.__getHandleBlur__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.timeouteClear = 0;
+    var _this$props = _this.props,
+        fieldValue = _this$props.fieldValue,
+        row = _this$props.row,
+        className = _this$props.className;
+
+    _this.focusInEditor = _this.focusInEditor.bind(_this);
+    _this.state = {
+      shakeEditor: false,
+      className: _util2.default.isFunction(className) ? className(fieldValue, row) : className
+    };
+    return _this;
+  }
+
+  _createClass(TableEditColumn, [{
+    key: '__getHandleBlur__REACT_HOT_LOADER__',
+    value: function __getHandleBlur__REACT_HOT_LOADER__() {
+      return this.__getHandleBlur__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__getHandleKeyPress__REACT_HOT_LOADER__',
+    value: function __getHandleKeyPress__REACT_HOT_LOADER__() {
+      return this.__getHandleKeyPress__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__getInputRef__REACT_HOT_LOADER__',
+    value: function __getInputRef__REACT_HOT_LOADER__() {
+      return this.__getInputRef__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__handleClick__REACT_HOT_LOADER__',
+    value: function __handleClick__REACT_HOT_LOADER__() {
+      return this.__handleClick__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__notifyToastr__REACT_HOT_LOADER__',
+    value: function __notifyToastr__REACT_HOT_LOADER__() {
+      return this.__notifyToastr__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__handleCustomUpdate__REACT_HOT_LOADER__',
+    value: function __handleCustomUpdate__REACT_HOT_LOADER__() {
+      return this.__handleCustomUpdate__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__handleBlur__REACT_HOT_LOADER__',
+    value: function __handleBlur__REACT_HOT_LOADER__() {
+      return this.__handleBlur__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__handleKeyPress__REACT_HOT_LOADER__',
+    value: function __handleKeyPress__REACT_HOT_LOADER__() {
+      return this.__handleKeyPress__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: 'valueShortCircuit',
+    value: function valueShortCircuit(value) {
+      return value === null || typeof value === 'undefined' ? '' : value;
+    }
+  }, {
+    key: '__handleKeyPress__REACT_HOT_LOADER__',
+    value: function __handleKeyPress__REACT_HOT_LOADER__(e) {
+      if (e.keyCode === 13 || e.keyCode === 9) {
+        // Pressed ENTER or TAB
+        var value = e.currentTarget.type === 'checkbox' ? this._getCheckBoxValue(e) : e.currentTarget.value;
+
+        if (e.keyCode === 9 && this.props.blurToSave || !this.validator(value)) {
+          return;
+        }
+
+        if (e.keyCode === 13) {
+          this.props.completeEdit(value, this.props.rowIndex, this.props.colIndex);
+        } else {
+          this.props.onTab(this.props.rowIndex + 1, this.props.colIndex + 1, 'tab', e);
+          e.preventDefault();
+        }
+      } else if (e.keyCode === 27) {
+        this.props.completeEdit(null, this.props.rowIndex, this.props.colIndex);
+      } else if (e.type === 'click' && !this.props.blurToSave) {
+        // textarea click save button
+        var _value = e.target.parentElement.firstChild.value;
+        if (!this.validator(_value)) {
+          return;
+        }
+        this.props.completeEdit(_value, this.props.rowIndex, this.props.colIndex);
+      }
+    }
+  }, {
+    key: '__handleBlur__REACT_HOT_LOADER__',
+    value: function __handleBlur__REACT_HOT_LOADER__(e) {
+      e.stopPropagation();
+      if (this.props.blurToSave) {
+        var value = e.currentTarget.type === 'checkbox' ? this._getCheckBoxValue(e) : e.currentTarget.value;
+        if (!this.validator(value)) {
+          return false;
+        }
+        this.props.completeEdit(value, this.props.rowIndex, this.props.colIndex);
+      } else if (this.props.blurToEscape) {
+        this.props.completeEdit(null, this.props.rowIndex, this.props.colIndex);
+      }
+    }
+  }, {
+    key: '__handleCustomUpdate__REACT_HOT_LOADER__',
+
+
+    // modified by iuculanop
+    // BEGIN
+    value: function __handleCustomUpdate__REACT_HOT_LOADER__(value) {
+      if (!this.validator(value)) {
+        return;
+      }
+      this.props.completeEdit(value, this.props.rowIndex, this.props.colIndex);
+    }
+  }, {
+    key: 'validator',
+    value: function validator(value) {
+      var ts = this;
+      var valid = true;
+      if (ts.props.editable.validator) {
+        var checkVal = ts.props.editable.validator(value, this.props.row);
+        var responseType = typeof checkVal === 'undefined' ? 'undefined' : _typeof(checkVal);
+        if (responseType !== 'object' && checkVal !== true) {
+          valid = false;
+          this.notifyToastr('error', checkVal, '');
+        } else if (responseType === 'object' && checkVal.isValid !== true) {
+          valid = false;
+          this.notifyToastr(checkVal.notification.type, checkVal.notification.msg, checkVal.notification.title);
+        }
+        if (!valid) {
+          // animate input
+          ts.clearTimeout();
+          var _props = this.props,
+              invalidColumnClassName = _props.invalidColumnClassName,
+              row = _props.row;
+
+          var className = _util2.default.isFunction(invalidColumnClassName) ? invalidColumnClassName(value, row) : invalidColumnClassName;
+          ts.setState({ shakeEditor: true, className: className });
+          ts.timeouteClear = setTimeout(function () {
+            ts.setState({ shakeEditor: false });
+          }, 300);
+          this.focusInEditor();
+          return valid;
+        }
+      }
+      return valid;
+    }
+    // END
+
+  }, {
+    key: '__notifyToastr__REACT_HOT_LOADER__',
+    value: function __notifyToastr__REACT_HOT_LOADER__(type, message, title) {
+      var toastr = true;
+      var beforeShowError = this.props.beforeShowError;
+
+      if (beforeShowError) {
+        toastr = beforeShowError(type, message, title);
+      }
+      if (toastr) {
+        (0, _Notification.notice)(type, message, title);
+      }
+    }
+  }, {
+    key: 'clearTimeout',
+    value: function (_clearTimeout) {
+      function clearTimeout() {
+        return _clearTimeout.apply(this, arguments);
+      }
+
+      clearTimeout.toString = function () {
+        return _clearTimeout.toString();
+      };
+
+      return clearTimeout;
+    }(function () {
+      if (this.timeouteClear !== 0) {
+        clearTimeout(this.timeouteClear);
+        this.timeouteClear = 0;
+      }
+    })
+  }, {
+    key: 'componentDidMount',
+    value: function componentDidMount() {
+      this.focusInEditor();
+      var dom = _reactDom2.default.findDOMNode(this);
+      if (this.props.isFocus) {
+        dom.focus();
+      } else {
+        dom.blur();
+      }
+    }
+  }, {
+    key: 'componentDidUpdate',
+    value: function componentDidUpdate() {
+      var dom = _reactDom2.default.findDOMNode(this);
+      if (this.props.isFocus) {
+        dom.focus();
+      } else {
+        dom.blur();
+      }
+    }
+  }, {
+    key: 'componentWillUnmount',
+    value: function componentWillUnmount() {
+      this.clearTimeout();
+    }
+  }, {
+    key: 'focusInEditor',
+    value: function focusInEditor() {
+      if (this.inputRef && _util2.default.isFunction(this.inputRef.focus)) {
+        this.inputRef.focus();
+      }
+    }
+  }, {
+    key: '__handleClick__REACT_HOT_LOADER__',
+    value: function __handleClick__REACT_HOT_LOADER__(e) {
+      if (e.target.tagName !== 'TD') {
+        e.stopPropagation();
+      }
+    }
+  }, {
+    key: '__getInputRef__REACT_HOT_LOADER__',
+    value: function __getInputRef__REACT_HOT_LOADER__(userRef) {
+      var _this2 = this;
+
+      return function (ref) {
+        _this2.inputRef = ref;
+        if (_util2.default.isFunction(userRef)) {
+          userRef(ref);
+        } else if (typeof userRef === 'string') {
+          throw new Error('Ref must be a function');
+        }
+      };
+    }
+  }, {
+    key: '__getHandleKeyPress__REACT_HOT_LOADER__',
+    value: function __getHandleKeyPress__REACT_HOT_LOADER__(customHandler) {
+      var _this3 = this;
+
+      return function (e) {
+        _this3.handleKeyPress(e);
+        if (_util2.default.isFunction(customHandler)) {
+          customHandler(e);
+        }
+      };
+    }
+  }, {
+    key: '__getHandleBlur__REACT_HOT_LOADER__',
+    value: function __getHandleBlur__REACT_HOT_LOADER__(customHandler) {
+      var _this4 = this;
+
+      return function (e) {
+        _this4.handleBlur(e);
+        if (_util2.default.isFunction(customHandler)) {
+          customHandler(e);
+        }
+      };
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      var _props2 = this.props,
+          editable = _props2.editable,
+          format = _props2.format,
+          customEditor = _props2.customEditor,
+          isFocus = _props2.isFocus,
+          customStyleWithNav = _props2.customStyleWithNav,
+          row = _props2.row,
+          attrs = _props2.attrs;
+      var shakeEditor = this.state.shakeEditor;
+
+      var attr = _extends({}, editable.attrs, {
+        ref: this.getInputRef(editable.attrs && editable.attrs.ref),
+        onKeyDown: this.getHandleKeyPress(editable.attrs && editable.attrs.onKeyDown),
+        onBlur: this.getHandleBlur(editable.attrs && editable.attrs.onBlur)
+      });
+      var style = { position: 'relative' };
+      var fieldValue = this.props.fieldValue;
+      var className = this.state.className;
+
+
+      if (editable.placeholder) {
+        attr.placeholder = editable.placeholder;
+        /* eslint-disable no-console */
+        console.warn('Setting editable.placeholder is deprecated. Use editable.attrs to set input attributes');
+        /* eslint-enable no-console */
+      }
+
+      var editorClass = (0, _classnames2.default)({ 'animated': shakeEditor, 'shake': shakeEditor });
+      fieldValue = fieldValue === 0 ? '0' : fieldValue;
+      var cellEditor = void 0;
+      if (customEditor) {
+        var customEditorProps = _extends({
+          row: row
+        }, attr, {
+          defaultValue: this.valueShortCircuit(fieldValue)
+        }, customEditor.customEditorParameters);
+        cellEditor = customEditor.getElement(this.handleCustomUpdate, customEditorProps);
+      } else {
+        cellEditor = (0, _Editor2.default)(editable, attr, format, editorClass, this.valueShortCircuit(fieldValue), null, row);
+      }
+
+      if (isFocus) {
+        if (customStyleWithNav) {
+          var customStyle = _util2.default.isFunction(customStyleWithNav) ? customStyleWithNav(fieldValue, row) : customStyleWithNav;
+          style = _extends({}, style, customStyle);
+        } else {
+          className = className + ' default-focus-cell';
+        }
+      }
+
+      return _react2.default.createElement(
+        'td',
+        _extends({ ref: 'td'
+        }, attrs, {
+          style: style,
+          className: className,
+          onClick: this.handleClick }),
+        cellEditor
+      );
+    }
+  }, {
+    key: '_getCheckBoxValue',
+    value: function _getCheckBoxValue(e) {
+      var value = '';
+      var values = e.currentTarget.value.split(':');
+      value = e.currentTarget.checked ? values[0] : values[1];
+      return value;
+    }
+  }]);
+
+  return TableEditColumn;
+}(_react.Component);
+
+TableEditColumn.propTypes = {
+  completeEdit: _propTypes2.default.func,
+  rowIndex: _propTypes2.default.number,
+  colIndex: _propTypes2.default.number,
+  blurToSave: _propTypes2.default.bool,
+  blurToEscape: _propTypes2.default.bool,
+  editable: _propTypes2.default.oneOfType([_propTypes2.default.bool, _propTypes2.default.object]),
+  format: _propTypes2.default.oneOfType([_propTypes2.default.bool, _propTypes2.default.func]),
+  row: _propTypes2.default.any,
+  fieldValue: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.bool, _propTypes2.default.number, _propTypes2.default.array, _propTypes2.default.object]),
+  className: _propTypes2.default.any,
+  beforeShowError: _propTypes2.default.func,
+  isFocus: _propTypes2.default.bool,
+  attrs: _propTypes2.default.object,
+  customStyleWithNav: _propTypes2.default.oneOfType([_propTypes2.default.func, _propTypes2.default.object])
+};
+
+var _default = TableEditColumn;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(TableEditColumn, 'TableEditColumn', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/TableEditColumn.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/TableEditColumn.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/TableFilter.js

@@ -0,0 +1,156 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _Const = require('./Const');
+
+var _Const2 = _interopRequireDefault(_Const);
+
+var _classnames = require('classnames');
+
+var _classnames2 = _interopRequireDefault(_classnames);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 TableFilter = function (_Component) {
+  _inherits(TableFilter, _Component);
+
+  function TableFilter(props) {
+    _classCallCheck(this, TableFilter);
+
+    var _this = _possibleConstructorReturn(this, (TableFilter.__proto__ || Object.getPrototypeOf(TableFilter)).call(this, props));
+
+    _this.handleKeyUp = function () {
+      return _this.__handleKeyUp__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.filterObj = {};
+    return _this;
+  }
+
+  _createClass(TableFilter, [{
+    key: '__handleKeyUp__REACT_HOT_LOADER__',
+    value: function __handleKeyUp__REACT_HOT_LOADER__() {
+      return this.__handleKeyUp__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__handleKeyUp__REACT_HOT_LOADER__',
+    value: function __handleKeyUp__REACT_HOT_LOADER__(e) {
+      var _e$currentTarget = e.currentTarget,
+          value = _e$currentTarget.value,
+          name = _e$currentTarget.name;
+
+      if (value.trim() === '') {
+        delete this.filterObj[name];
+      } else {
+        this.filterObj[name] = value;
+      }
+      this.props.onFilter(this.filterObj);
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      var _props = this.props,
+          striped = _props.striped,
+          condensed = _props.condensed,
+          rowSelectType = _props.rowSelectType,
+          columns = _props.columns;
+
+      var tableClasses = (0, _classnames2.default)('table', {
+        'table-striped': striped,
+        'table-condensed': condensed
+      });
+      var selectRowHeader = null;
+
+      if (rowSelectType === _Const2.default.ROW_SELECT_SINGLE || rowSelectType === _Const2.default.ROW_SELECT_MULTI) {
+        var style = {
+          width: 35,
+          paddingLeft: 0,
+          paddingRight: 0
+        };
+        selectRowHeader = _react2.default.createElement(
+          'th',
+          { style: style, key: -1 },
+          'Filter'
+        );
+      }
+
+      var filterField = columns.map(function (column) {
+        var hidden = column.hidden,
+            width = column.width,
+            name = column.name;
+
+        var thStyle = {
+          display: hidden ? 'none' : null,
+          width: width
+        };
+        return _react2.default.createElement(
+          'th',
+          { key: name, style: thStyle },
+          _react2.default.createElement(
+            'div',
+            { className: 'th-inner table-header-column' },
+            _react2.default.createElement('input', { size: '10', type: 'text',
+              placeholder: name, name: name, onKeyUp: this.handleKeyUp })
+          )
+        );
+      }, this);
+
+      return _react2.default.createElement(
+        'table',
+        { className: tableClasses, style: { marginTop: 5 } },
+        _react2.default.createElement(
+          'thead',
+          null,
+          _react2.default.createElement(
+            'tr',
+            { style: { borderBottomStyle: 'hidden' } },
+            selectRowHeader,
+            filterField
+          )
+        )
+      );
+    }
+  }]);
+
+  return TableFilter;
+}(_react.Component);
+
+TableFilter.propTypes = {
+  columns: _propTypes2.default.array,
+  rowSelectType: _propTypes2.default.string,
+  onFilter: _propTypes2.default.func
+};
+var _default = TableFilter;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(TableFilter, 'TableFilter', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/TableFilter.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/TableFilter.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/TableFooter.js

@@ -0,0 +1,142 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _classnames = require('classnames');
+
+var _classnames2 = _interopRequireDefault(_classnames);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 TableFooter = function (_Component) {
+  _inherits(TableFooter, _Component);
+
+  function TableFooter() {
+    _classCallCheck(this, TableFooter);
+
+    return _possibleConstructorReturn(this, (TableFooter.__proto__ || Object.getPrototypeOf(TableFooter)).apply(this, arguments));
+  }
+
+  _createClass(TableFooter, [{
+    key: 'render',
+    value: function render() {
+      var _this2 = this;
+
+      var _props = this.props,
+          hideSelectColumn = _props.hideSelectColumn,
+          expandColumnVisible = _props.expandColumnVisible;
+
+      var containerClasses = (0, _classnames2.default)('react-bs-container-footer', 'table-footer-wrapper');
+      var tableClasses = (0, _classnames2.default)('table', 'table-hover', {
+        'table-bordered': this.props.bordered,
+        'table-condensed': this.props.condensed
+      }, this.props.tableFooterClass);
+      return _react2.default.createElement(
+        'div',
+        { ref: 'container', className: containerClasses, style: this.props.style },
+        this.props.children.map(function (footerItem, footerItemIndex) {
+          return _react2.default.createElement(
+            'span',
+            { key: footerItemIndex },
+            _react2.default.createElement(
+              'table',
+              { className: tableClasses },
+              _react2.default.cloneElement(_this2.props.colGroups),
+              _react2.default.createElement(
+                'tfoot',
+                null,
+                _react2.default.createElement(
+                  'tr',
+                  { ref: 'footer' },
+                  hideSelectColumn ? null : _this2.renderSelectionOrExpandCol(),
+                  !expandColumnVisible ? null : _this2.renderSelectionOrExpandCol(),
+                  _this2.props.columns.map(function (columnItem, colIndex) {
+                    if (!columnItem.hidden) {
+                      var footerObj = footerItem.filter(function (item) {
+                        return item.columnIndex === colIndex;
+                      });
+                      var footerData = void 0;
+                      var thAlignment = 'left';
+                      if (footerObj.length) {
+                        thAlignment = footerObj[0].align;
+                        if (footerObj[0].formatter) {
+                          footerData = footerObj[0].formatter(_this2.props.footerFormatterReturnData);
+                        } else {
+                          footerData = footerObj[0].label;
+                        }
+                      } else {
+                        footerData = '';
+                      }
+                      return _react2.default.createElement(
+                        'th',
+                        {
+                          key: colIndex,
+                          style: {
+                            minWidth: _this2.props.columns[colIndex].width + 'px',
+                            textAlign: thAlignment
+                          } },
+                        footerData
+                      );
+                    }
+                  })
+                )
+              )
+            )
+          );
+        })
+      );
+    }
+  }, {
+    key: 'renderSelectionOrExpandCol',
+    value: function renderSelectionOrExpandCol() {
+      return _react2.default.createElement('th', null);
+    }
+  }]);
+
+  return TableFooter;
+}(_react.Component);
+
+TableFooter.propTypes = {
+  tableHeaderClass: _propTypes2.default.string,
+  style: _propTypes2.default.object,
+  hideSelectColumn: _propTypes2.default.bool,
+  expandColumnVisible: _propTypes2.default.bool,
+  bordered: _propTypes2.default.bool,
+  condensed: _propTypes2.default.bool,
+  isFiltered: _propTypes2.default.bool,
+  sortIndicator: _propTypes2.default.bool
+};
+
+var _default = TableFooter;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(TableFooter, 'TableFooter', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/TableFooter.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/TableFooter.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/TableHeader.js

@@ -0,0 +1,281 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _reactDom = require('react-dom');
+
+var _reactDom2 = _interopRequireDefault(_reactDom);
+
+var _Const = require('./Const');
+
+var _Const2 = _interopRequireDefault(_Const);
+
+var _classnames = require('classnames');
+
+var _classnames2 = _interopRequireDefault(_classnames);
+
+var _SelectRowHeaderColumn = require('./SelectRowHeaderColumn');
+
+var _SelectRowHeaderColumn2 = _interopRequireDefault(_SelectRowHeaderColumn);
+
+var _ExpandRowHeaderColumn = require('./ExpandRowHeaderColumn');
+
+var _ExpandRowHeaderColumn2 = _interopRequireDefault(_ExpandRowHeaderColumn);
+
+var _util = require('./util');
+
+var _util2 = _interopRequireDefault(_util);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: 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(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 Checkbox = function (_Component) {
+  _inherits(Checkbox, _Component);
+
+  function Checkbox() {
+    _classCallCheck(this, Checkbox);
+
+    return _possibleConstructorReturn(this, (Checkbox.__proto__ || Object.getPrototypeOf(Checkbox)).apply(this, arguments));
+  }
+
+  _createClass(Checkbox, [{
+    key: 'componentDidMount',
+    value: function componentDidMount() {
+      this.update(this.props.checked);
+    }
+  }, {
+    key: 'componentWillReceiveProps',
+    value: function componentWillReceiveProps(props) {
+      this.update(props.checked);
+    }
+  }, {
+    key: 'update',
+    value: function update(checked) {
+      _reactDom2.default.findDOMNode(this).indeterminate = checked === 'indeterminate';
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      return _react2.default.createElement('input', { className: 'react-bs-select-all',
+        type: 'checkbox',
+        checked: this.props.checked,
+        onChange: this.props.onChange });
+    }
+  }]);
+
+  return Checkbox;
+}(_react.Component);
+
+function getSortOrder(sortList, field, enableSort) {
+  if (!enableSort) return undefined;
+  var result = sortList.filter(function (sortObj) {
+    return sortObj.sortField === field;
+  });
+  if (result.length > 0) {
+    return result[0].order;
+  } else {
+    return undefined;
+  }
+}
+
+var TableHeader = function (_Component2) {
+  _inherits(TableHeader, _Component2);
+
+  function TableHeader() {
+    var _ref;
+
+    var _temp, _this2, _ret;
+
+    _classCallCheck(this, TableHeader);
+
+    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    return _ret = (_temp = (_this2 = _possibleConstructorReturn(this, (_ref = TableHeader.__proto__ || Object.getPrototypeOf(TableHeader)).call.apply(_ref, [this].concat(args))), _this2), _this2.getHeaderColGrouop = function () {
+      var _this3;
+
+      return (_this3 = _this2).__getHeaderColGrouop__REACT_HOT_LOADER__.apply(_this3, arguments);
+    }, _temp), _possibleConstructorReturn(_this2, _ret);
+  }
+
+  _createClass(TableHeader, [{
+    key: '__getHeaderColGrouop__REACT_HOT_LOADER__',
+    value: function __getHeaderColGrouop__REACT_HOT_LOADER__() {
+      return this.__getHeaderColGrouop__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      var _props = this.props,
+          sortIndicator = _props.sortIndicator,
+          sortList = _props.sortList,
+          onSort = _props.onSort,
+          reset = _props.reset,
+          version = _props.version,
+          condensed = _props.condensed,
+          bordered = _props.bordered;
+
+      var containerClasses = (0, _classnames2.default)('react-bs-container-header', 'table-header-wrapper', this.props.headerContainerClass);
+      var customTableClasses = {
+        'table-bordered': bordered
+      };
+      if (condensed) {
+        if (_util2.default.isBootstrap4(version)) customTableClasses['table-sm'] = true;else customTableClasses['table-condensed'] = true;
+      }
+      var tableClasses = (0, _classnames2.default)('table', 'table-hover', customTableClasses, this.props.tableHeaderClass);
+
+      var rowCount = Math.max.apply(Math, _toConsumableArray(_react2.default.Children.map(this.props.children, function (elm) {
+        return elm && elm.props.row ? Number(elm.props.row) : 0;
+      })));
+
+      var rows = [];
+      var rowKey = 0;
+
+      rows[0] = [];
+      rows[0].push([this.props.expandColumnVisible && this.props.expandColumnBeforeSelectColumn && _react2.default.createElement(_ExpandRowHeaderColumn2.default, { key: 'expandCol', rowCount: rowCount + 1 })], [this.renderSelectRowHeader(rowCount + 1, rowKey++)], [this.props.expandColumnVisible && !this.props.expandColumnBeforeSelectColumn && _react2.default.createElement(_ExpandRowHeaderColumn2.default, { key: 'expandCol', rowCount: rowCount + 1 })]);
+
+      _react2.default.Children.forEach(this.props.children, function (elm) {
+        if (elm === null || elm === undefined) {
+          // Skip null or undefined elements.
+          return;
+        }
+        var _elm$props = elm.props,
+            dataField = _elm$props.dataField,
+            dataSort = _elm$props.dataSort;
+
+        var sort = getSortOrder(sortList, dataField, dataSort);
+        var rowIndex = elm.props.row ? Number(elm.props.row) : 0;
+        var rowSpan = elm.props.rowSpan ? Number(elm.props.rowSpan) : 1;
+        if (rows[rowIndex] === undefined) {
+          rows[rowIndex] = [];
+        }
+        if (rowSpan + rowIndex === rowCount + 1) {
+          rows[rowIndex].push(_react2.default.cloneElement(elm, { reset: reset, key: rowKey++, onSort: onSort, sort: sort, sortIndicator: sortIndicator, isOnlyHead: false, version: version }));
+        } else {
+          rows[rowIndex].push(_react2.default.cloneElement(elm, { key: rowKey++, isOnlyHead: true, version: version }));
+        }
+      });
+
+      var trs = rows.map(function (row, indexRow) {
+        return _react2.default.createElement(
+          'tr',
+          { key: indexRow },
+          row
+        );
+      });
+
+      return _react2.default.createElement(
+        'div',
+        { ref: 'container', className: containerClasses, style: this.props.style },
+        _react2.default.createElement(
+          'table',
+          { className: tableClasses },
+          _react2.default.cloneElement(this.props.colGroups, { ref: 'headerGrp' }),
+          _react2.default.createElement(
+            'thead',
+            { ref: 'header' },
+            trs
+          )
+        )
+      );
+    }
+  }, {
+    key: '__getHeaderColGrouop__REACT_HOT_LOADER__',
+    value: function __getHeaderColGrouop__REACT_HOT_LOADER__() {
+      return this.refs.headerGrp.childNodes;
+    }
+  }, {
+    key: 'renderSelectRowHeader',
+    value: function renderSelectRowHeader(rowCount, rowKey) {
+      if (this.props.hideSelectColumn) {
+        return null;
+      } else if (this.props.customComponent) {
+        var CustomComponent = this.props.customComponent;
+        return _react2.default.createElement(
+          _SelectRowHeaderColumn2.default,
+          { key: rowKey, rowCount: rowCount },
+          _react2.default.createElement(CustomComponent, { type: 'checkbox', checked: this.props.isSelectAll,
+            indeterminate: this.props.isSelectAll === 'indeterminate', disabled: false,
+            onChange: this.props.onSelectAllRow, rowIndex: 'Header' })
+        );
+      } else if (this.props.rowSelectType === _Const2.default.ROW_SELECT_SINGLE) {
+        return _react2.default.createElement(_SelectRowHeaderColumn2.default, { key: rowKey, rowCount: rowCount });
+      } else if (this.props.rowSelectType === _Const2.default.ROW_SELECT_MULTI) {
+        return _react2.default.createElement(
+          _SelectRowHeaderColumn2.default,
+          { key: rowKey, rowCount: rowCount },
+          _react2.default.createElement(Checkbox, {
+            onChange: this.props.onSelectAllRow,
+            checked: this.props.isSelectAll })
+        );
+      } else {
+        return null;
+      }
+    }
+  }]);
+
+  return TableHeader;
+}(_react.Component);
+
+TableHeader.propTypes = {
+  headerContainerClass: _propTypes2.default.string,
+  tableHeaderClass: _propTypes2.default.string,
+  style: _propTypes2.default.object,
+  rowSelectType: _propTypes2.default.string,
+  onSort: _propTypes2.default.func,
+  onSelectAllRow: _propTypes2.default.func,
+  sortList: _propTypes2.default.array,
+  hideSelectColumn: _propTypes2.default.bool,
+  bordered: _propTypes2.default.bool,
+  condensed: _propTypes2.default.bool,
+  isFiltered: _propTypes2.default.bool,
+  isSelectAll: _propTypes2.default.oneOf([true, 'indeterminate', false]),
+  sortIndicator: _propTypes2.default.bool,
+  customComponent: _propTypes2.default.func,
+  colGroups: _propTypes2.default.element,
+  reset: _propTypes2.default.bool,
+  expandColumnVisible: _propTypes2.default.bool,
+  expandColumnComponent: _propTypes2.default.func,
+  expandColumnBeforeSelectColumn: _propTypes2.default.bool,
+  version: _propTypes2.default.string
+};
+
+var _default = TableHeader;
+exports.default = _default;
+;
+
+var _temp2 = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(Checkbox, 'Checkbox', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/TableHeader.js');
+
+  __REACT_HOT_LOADER__.register(getSortOrder, 'getSortOrder', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/TableHeader.js');
+
+  __REACT_HOT_LOADER__.register(TableHeader, 'TableHeader', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/TableHeader.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/TableHeader.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/TableHeaderColumn.js

@@ -0,0 +1,453 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _classnames = require('classnames');
+
+var _classnames2 = _interopRequireDefault(_classnames);
+
+var _Const = require('./Const');
+
+var _Const2 = _interopRequireDefault(_Const);
+
+var _util = require('./util');
+
+var _util2 = _interopRequireDefault(_util);
+
+var _Date = require('./filters/Date');
+
+var _Date2 = _interopRequireDefault(_Date);
+
+var _Text = require('./filters/Text');
+
+var _Text2 = _interopRequireDefault(_Text);
+
+var _Regex = require('./filters/Regex');
+
+var _Regex2 = _interopRequireDefault(_Regex);
+
+var _Select = require('./filters/Select');
+
+var _Select2 = _interopRequireDefault(_Select);
+
+var _Number = require('./filters/Number');
+
+var _Number2 = _interopRequireDefault(_Number);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; } /* eslint default-case: 0 */
+/* eslint guard-for-in: 0 */
+
+
+var TableHeaderColumn = function (_Component) {
+  _inherits(TableHeaderColumn, _Component);
+
+  function TableHeaderColumn(props) {
+    _classCallCheck(this, TableHeaderColumn);
+
+    var _this = _possibleConstructorReturn(this, (TableHeaderColumn.__proto__ || Object.getPrototypeOf(TableHeaderColumn)).call(this, props));
+
+    _this.handleColumnClick = function () {
+      return _this.__handleColumnClick__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.handleFilter = _this.handleFilter.bind(_this);
+    return _this;
+  }
+
+  _createClass(TableHeaderColumn, [{
+    key: '__handleColumnClick__REACT_HOT_LOADER__',
+    value: function __handleColumnClick__REACT_HOT_LOADER__() {
+      return this.__handleColumnClick__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: 'componentWillReceiveProps',
+    value: function componentWillReceiveProps(nextProps) {
+      if (nextProps.reset) {
+        this.cleanFiltered();
+      }
+
+      // If column not displaying the same dataField, reset the filter accordingly
+      if (nextProps.filter && nextProps.dataField !== this.props.dataField) {
+        var emitter = nextProps.filter.emitter || {};
+        var currentFilter = emitter.currentFilter || {};
+        var filter = currentFilter[nextProps.dataField];
+        var value = filter ? filter.value : '';
+
+        var _ref = this.getFilters() || {},
+            ref = _ref.ref;
+
+        if (this.refs[ref]) {
+          this.refs[ref].setState({ value: value });
+        }
+      }
+    }
+  }, {
+    key: '__handleColumnClick__REACT_HOT_LOADER__',
+    value: function __handleColumnClick__REACT_HOT_LOADER__() {
+      if (this.props.isOnlyHead || !this.props.dataSort) return;
+      var order = this.props.sort;
+
+      if (!order && this.props.defaultASC) order = _Const2.default.SORT_ASC;else order = this.props.sort === _Const2.default.SORT_DESC ? _Const2.default.SORT_ASC : _Const2.default.SORT_DESC;
+      this.props.onSort(order, this.props.dataField);
+    }
+  }, {
+    key: 'handleFilter',
+    value: function handleFilter(value, type) {
+      var filter = this.props.filter;
+
+      filter.emitter.handleFilter(this.props.dataField, value, type, filter);
+    }
+  }, {
+    key: 'getFilters',
+    value: function getFilters() {
+      var _props = this.props,
+          headerText = _props.headerText,
+          children = _props.children;
+
+      switch (this.props.filter.type) {
+        case _Const2.default.FILTER_TYPE.TEXT:
+          {
+            return _react2.default.createElement(_Text2.default, _extends({ ref: 'textFilter' }, this.props.filter, {
+              columnName: headerText || children, filterHandler: this.handleFilter }));
+          }
+        case _Const2.default.FILTER_TYPE.REGEX:
+          {
+            return _react2.default.createElement(_Regex2.default, _extends({ ref: 'regexFilter' }, this.props.filter, {
+              columnName: headerText || children, filterHandler: this.handleFilter }));
+          }
+        case _Const2.default.FILTER_TYPE.SELECT:
+          {
+            return _react2.default.createElement(_Select2.default, _extends({ ref: 'selectFilter' }, this.props.filter, {
+              columnName: headerText || children, filterHandler: this.handleFilter }));
+          }
+        case _Const2.default.FILTER_TYPE.NUMBER:
+          {
+            return _react2.default.createElement(_Number2.default, _extends({ ref: 'numberFilter' }, this.props.filter, {
+              columnName: headerText || children, filterHandler: this.handleFilter }));
+          }
+        case _Const2.default.FILTER_TYPE.DATE:
+          {
+            return _react2.default.createElement(_Date2.default, _extends({ ref: 'dateFilter' }, this.props.filter, {
+              columnName: headerText || children, filterHandler: this.handleFilter }));
+          }
+        case _Const2.default.FILTER_TYPE.CUSTOM:
+          {
+            var elm = this.props.filter.getElement(this.handleFilter, this.props.filter.customFilterParameters);
+
+            return _react2.default.cloneElement(elm, { ref: 'customFilter' });
+          }
+      }
+    }
+  }, {
+    key: 'componentDidMount',
+    value: function componentDidMount() {
+      this.refs['header-col'].setAttribute('data-field', this.props.dataField);
+    }
+  }, {
+    key: 'renderDefaultCaret',
+    value: function renderDefaultCaret(dataSort, isBootstrap4) {
+      if (!dataSort) return null;
+      if (isBootstrap4) {
+        return _react2.default.createElement('span', { className: 'order fa fa-sort',
+          style: { margin: '10px 0 10px 5px', color: '#ccc' } });
+      } else {
+        return _react2.default.createElement(
+          'span',
+          { className: 'order' },
+          _react2.default.createElement(
+            'span',
+            { className: 'dropdown' },
+            _react2.default.createElement('span', { className: 'caret', style: { margin: '10px 0 10px 5px', color: '#ccc' } })
+          ),
+          _react2.default.createElement(
+            'span',
+            { className: 'dropup' },
+            _react2.default.createElement('span', { className: 'caret', style: { margin: '10px 0', color: '#ccc' } })
+          )
+        );
+      }
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      var defaultCaret = void 0;
+      var sortCaret = void 0;
+      var sortClass = void 0;
+      var _props2 = this.props,
+          headerText = _props2.headerText,
+          dataAlign = _props2.dataAlign,
+          dataField = _props2.dataField,
+          headerAlign = _props2.headerAlign,
+          headerTitle = _props2.headerTitle,
+          hidden = _props2.hidden,
+          sort = _props2.sort,
+          dataSort = _props2.dataSort,
+          sortIndicator = _props2.sortIndicator,
+          children = _props2.children,
+          caretRender = _props2.caretRender,
+          className = _props2.className,
+          isOnlyHead = _props2.isOnlyHead,
+          version = _props2.version,
+          customSortClass = _props2.sortHeaderColumnClassName,
+          style = _props2.thStyle;
+
+      var thStyle = _extends({
+        textAlign: headerAlign || dataAlign,
+        display: hidden ? 'none' : null
+      }, style);
+      var isBootstrap4 = _util2.default.isBootstrap4(version);
+      if (!isOnlyHead) {
+        if (sortIndicator) {
+          defaultCaret = this.renderDefaultCaret(dataSort, isBootstrap4);
+        }
+        sortCaret = sort ? _util2.default.renderReactSortCaret(sort, isBootstrap4) : defaultCaret;
+        if (caretRender) {
+          sortCaret = caretRender(sort, dataField);
+        }
+      }
+
+      if (sort) {
+        sortClass = _util2.default.isFunction(customSortClass) ? customSortClass(sort, dataField) : customSortClass;
+      }
+      var classes = (0, _classnames2.default)(_util2.default.isFunction(className) ? className() : className, !isOnlyHead && dataSort ? 'sort-column' : '', sortClass);
+
+      var attr = {};
+      if (headerTitle) {
+        if (typeof children === 'string' && !headerText) {
+          attr.title = children;
+        } else {
+          attr.title = headerText;
+        }
+      }
+      return _react2.default.createElement(
+        'th',
+        _extends({ ref: 'header-col',
+          className: classes,
+          style: thStyle,
+          onClick: this.handleColumnClick,
+          rowSpan: this.props.rowSpan,
+          colSpan: this.props.colSpan,
+          'data-is-only-head': this.props.isOnlyHead
+        }, attr),
+        children,
+        sortCaret,
+        _react2.default.createElement(
+          'div',
+          { onClick: function onClick(e) {
+              return e.stopPropagation();
+            } },
+          this.props.filter && !isOnlyHead ? this.getFilters() : null
+        )
+      );
+    }
+  }, {
+    key: 'cleanFiltered',
+    value: function cleanFiltered() {
+      if (!this.props.filter) return;
+
+      switch (this.props.filter.type) {
+        case _Const2.default.FILTER_TYPE.TEXT:
+          {
+            this.refs.textFilter.cleanFiltered();
+            break;
+          }
+        case _Const2.default.FILTER_TYPE.REGEX:
+          {
+            this.refs.regexFilter.cleanFiltered();
+            break;
+          }
+        case _Const2.default.FILTER_TYPE.SELECT:
+          {
+            this.refs.selectFilter.cleanFiltered();
+            break;
+          }
+        case _Const2.default.FILTER_TYPE.NUMBER:
+          {
+            this.refs.numberFilter.cleanFiltered();
+            break;
+          }
+        case _Const2.default.FILTER_TYPE.DATE:
+          {
+            this.refs.dateFilter.cleanFiltered();
+            break;
+          }
+        case _Const2.default.FILTER_TYPE.CUSTOM:
+          {
+            this.refs.customFilter.cleanFiltered();
+            break;
+          }
+      }
+    }
+  }, {
+    key: 'applyFilter',
+    value: function applyFilter(val) {
+      if (!this.props.filter) return;
+      switch (this.props.filter.type) {
+        case _Const2.default.FILTER_TYPE.TEXT:
+          {
+            this.refs.textFilter.applyFilter(val);
+            break;
+          }
+        case _Const2.default.FILTER_TYPE.REGEX:
+          {
+            this.refs.regexFilter.applyFilter(val);
+            break;
+          }
+        case _Const2.default.FILTER_TYPE.SELECT:
+          {
+            this.refs.selectFilter.applyFilter(val);
+            break;
+          }
+        case _Const2.default.FILTER_TYPE.NUMBER:
+          {
+            this.refs.numberFilter.applyFilter(val);
+            break;
+          }
+        case _Const2.default.FILTER_TYPE.DATE:
+          {
+            this.refs.dateFilter.applyFilter(val);
+            break;
+          }
+      }
+    }
+  }]);
+
+  return TableHeaderColumn;
+}(_react.Component);
+
+var filterTypeArray = [];
+for (var key in _Const2.default.FILTER_TYPE) {
+  filterTypeArray.push(_Const2.default.FILTER_TYPE[key]);
+}
+
+TableHeaderColumn.propTypes = {
+  dataField: _propTypes2.default.string,
+  dataAlign: _propTypes2.default.string,
+  headerAlign: _propTypes2.default.string,
+  headerTitle: _propTypes2.default.bool,
+  headerText: _propTypes2.default.string,
+  dataSort: _propTypes2.default.bool,
+  onSort: _propTypes2.default.func,
+  dataFormat: _propTypes2.default.func,
+  csvFormat: _propTypes2.default.func,
+  csvHeader: _propTypes2.default.string,
+  csvFieldType: _propTypes2.default.oneOf([_Const2.default.CSV_STRING_TYPE, _Const2.default.CSV_NUMBER_TYPE]),
+  isKey: _propTypes2.default.bool,
+  editable: _propTypes2.default.any,
+  hidden: _propTypes2.default.bool,
+  hiddenOnInsert: _propTypes2.default.bool,
+  searchable: _propTypes2.default.bool,
+  className: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.func]),
+  width: _propTypes2.default.string,
+  sortFunc: _propTypes2.default.func,
+  sortFuncExtraData: _propTypes2.default.any,
+  sortHeaderColumnClassName: _propTypes2.default.any,
+  columnClassName: _propTypes2.default.any,
+  editColumnClassName: _propTypes2.default.any,
+  invalidEditColumnClassName: _propTypes2.default.any,
+  columnTitle: _propTypes2.default.oneOfType([_propTypes2.default.bool, _propTypes2.default.func, _propTypes2.default.string]),
+  filterFormatted: _propTypes2.default.bool,
+  filterValue: _propTypes2.default.func,
+  sort: _propTypes2.default.string,
+  caretRender: _propTypes2.default.func,
+  formatExtraData: _propTypes2.default.any,
+  csvFormatExtraData: _propTypes2.default.any,
+  filter: _propTypes2.default.shape({
+    type: _propTypes2.default.oneOf(filterTypeArray),
+    delay: _propTypes2.default.number,
+    options: _propTypes2.default.oneOfType([_propTypes2.default.object, // for SelectFilter
+    _propTypes2.default.arrayOf(_propTypes2.default.number) // for NumberFilter
+    ]),
+    numberComparators: _propTypes2.default.arrayOf(_propTypes2.default.string),
+    emitter: _propTypes2.default.object,
+    placeholder: _propTypes2.default.string,
+    getElement: _propTypes2.default.func,
+    customFilterParameters: _propTypes2.default.object,
+    condition: _propTypes2.default.oneOf([_Const2.default.FILTER_COND_EQ, _Const2.default.FILTER_COND_LIKE])
+  }),
+  sortIndicator: _propTypes2.default.bool,
+  export: _propTypes2.default.bool,
+  expandable: _propTypes2.default.bool,
+  tdAttr: _propTypes2.default.object,
+  editTdAttr: _propTypes2.default.object,
+  tdStyle: _propTypes2.default.oneOfType([_propTypes2.default.func, _propTypes2.default.object]),
+  thStyle: _propTypes2.default.object,
+  keyValidator: _propTypes2.default.bool,
+  defaultASC: _propTypes2.default.bool
+};
+
+TableHeaderColumn.defaultProps = {
+  dataAlign: 'left',
+  headerAlign: undefined,
+  headerTitle: true,
+  dataSort: false,
+  dataFormat: undefined,
+  csvFormat: undefined,
+  csvHeader: undefined,
+  csvFieldType: _Const2.default.CSV_STRING_TYPE,
+  isKey: false,
+  editable: true,
+  onSort: undefined,
+  hidden: false,
+  hiddenOnInsert: false,
+  searchable: true,
+  className: '',
+  columnTitle: false,
+  width: null,
+  sortFunc: undefined,
+  columnClassName: '',
+  editColumnClassName: '',
+  invalidEditColumnClassName: '',
+  filterFormatted: false,
+  filterValue: undefined,
+  sort: undefined,
+  formatExtraData: undefined,
+  sortFuncExtraData: undefined,
+  filter: undefined,
+  sortIndicator: true,
+  expandable: true,
+  tdAttr: undefined,
+  editTdAttr: undefined,
+  tdStyle: undefined,
+  thStyle: undefined,
+  keyValidator: false,
+  defaultASC: false
+};
+
+var _default = TableHeaderColumn;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(TableHeaderColumn, 'TableHeaderColumn', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/TableHeaderColumn.js');
+
+  __REACT_HOT_LOADER__.register(filterTypeArray, 'filterTypeArray', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/TableHeaderColumn.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/TableHeaderColumn.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/TableRow.js

@@ -0,0 +1,252 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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; }; }();
+
+var _classnames = require('classnames');
+
+var _classnames2 = _interopRequireDefault(_classnames);
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _util = require('./util');
+
+var _util2 = _interopRequireDefault(_util);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; } /* eslint no-nested-ternary: 0 */
+
+
+var TableRow = function (_Component) {
+  _inherits(TableRow, _Component);
+
+  function TableRow(props) {
+    _classCallCheck(this, TableRow);
+
+    var _this = _possibleConstructorReturn(this, (TableRow.__proto__ || Object.getPrototypeOf(TableRow)).call(this, props));
+
+    _this.rowClick = function () {
+      return _this.__rowClick__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.expandRow = function () {
+      return _this.__expandRow__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.rowDoubleClick = function () {
+      return _this.__rowDoubleClick__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.rowMouseOut = function () {
+      return _this.__rowMouseOut__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.rowMouseOver = function () {
+      return _this.__rowMouseOver__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.clickNum = 0;
+    return _this;
+  }
+
+  _createClass(TableRow, [{
+    key: '__rowMouseOver__REACT_HOT_LOADER__',
+    value: function __rowMouseOver__REACT_HOT_LOADER__() {
+      return this.__rowMouseOver__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__rowMouseOut__REACT_HOT_LOADER__',
+    value: function __rowMouseOut__REACT_HOT_LOADER__() {
+      return this.__rowMouseOut__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__rowDoubleClick__REACT_HOT_LOADER__',
+    value: function __rowDoubleClick__REACT_HOT_LOADER__() {
+      return this.__rowDoubleClick__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__expandRow__REACT_HOT_LOADER__',
+    value: function __expandRow__REACT_HOT_LOADER__() {
+      return this.__expandRow__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__rowClick__REACT_HOT_LOADER__',
+    value: function __rowClick__REACT_HOT_LOADER__() {
+      return this.__rowClick__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__rowClick__REACT_HOT_LOADER__',
+    value: function __rowClick__REACT_HOT_LOADER__(e) {
+      var _this2 = this;
+
+      var rowIndex = this.props.index + 1;
+      var cellIndex = e.target.cellIndex;
+      if (this.props.onRowClick) this.props.onRowClick(rowIndex, cellIndex);
+      var _props = this.props,
+          selectRow = _props.selectRow,
+          unselectableRow = _props.unselectableRow,
+          isSelected = _props.isSelected,
+          onSelectRow = _props.onSelectRow,
+          onExpandRow = _props.onExpandRow,
+          dbClickToEdit = _props.dbClickToEdit;
+
+      if (selectRow) {
+        if (selectRow.clickToSelect && !unselectableRow) {
+          onSelectRow(rowIndex, !isSelected, e);
+        } else if (selectRow.clickToSelectAndEditCell && !unselectableRow) {
+          this.clickNum++;
+          /** if clickToSelectAndEditCell is enabled,
+           *  there should be a delay to prevent a selection changed when
+           *  user dblick to edit cell on same row but different cell
+          **/
+          setTimeout(function () {
+            if (_this2.clickNum === 1) {
+              onSelectRow(rowIndex, !isSelected, e);
+              onExpandRow(rowIndex, cellIndex);
+            }
+            _this2.clickNum = 0;
+          }, 200);
+        } else {
+          if (dbClickToEdit) {
+            this.expandRow(rowIndex, cellIndex);
+          }
+        }
+      }
+    }
+  }, {
+    key: '__expandRow__REACT_HOT_LOADER__',
+    value: function __expandRow__REACT_HOT_LOADER__(rowIndex, cellIndex) {
+      var _this3 = this;
+
+      this.clickNum++;
+      setTimeout(function () {
+        if (_this3.clickNum === 1) {
+          _this3.props.onExpandRow(rowIndex, cellIndex);
+        }
+        _this3.clickNum = 0;
+      }, 200);
+    }
+  }, {
+    key: '__rowDoubleClick__REACT_HOT_LOADER__',
+    value: function __rowDoubleClick__REACT_HOT_LOADER__(e) {
+      if (e.target.tagName !== 'INPUT' && e.target.tagName !== 'SELECT' && e.target.tagName !== 'TEXTAREA') {
+        if (this.props.onRowDoubleClick) {
+          this.props.onRowDoubleClick(this.props.index);
+        }
+      }
+    }
+  }, {
+    key: '__rowMouseOut__REACT_HOT_LOADER__',
+    value: function __rowMouseOut__REACT_HOT_LOADER__(e) {
+      var rowIndex = this.props.index;
+      if (this.props.onRowMouseOut) {
+        this.props.onRowMouseOut(rowIndex, e);
+      }
+    }
+  }, {
+    key: '__rowMouseOver__REACT_HOT_LOADER__',
+    value: function __rowMouseOver__REACT_HOT_LOADER__(e) {
+      var rowIndex = this.props.index;
+      if (this.props.onRowMouseOver) {
+        this.props.onRowMouseOver(rowIndex, e);
+      }
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      this.clickNum = 0;
+      var _props2 = this.props,
+          selectRow = _props2.selectRow,
+          row = _props2.row,
+          isSelected = _props2.isSelected,
+          className = _props2.className,
+          index = _props2.index;
+      var style = this.props.style;
+
+      var backgroundColor = null;
+      var selectRowClass = null;
+
+      if (selectRow) {
+        backgroundColor = _util2.default.isFunction(selectRow.bgColor) ? selectRow.bgColor(row, isSelected) : isSelected ? selectRow.bgColor : null;
+
+        selectRowClass = _util2.default.isFunction(selectRow.className) ? selectRow.className(row, isSelected) : isSelected ? selectRow.className : null;
+      }
+
+      if (_util2.default.isFunction(style)) {
+        style = style(row, index);
+      } else {
+        style = _extends({}, style) || {};
+      }
+      // the bgcolor of row selection always overwrite the bgcolor defined by global.
+      if (style && backgroundColor && isSelected) {
+        style.backgroundColor = backgroundColor;
+      }
+      var trCss = {
+        style: _extends({}, style),
+        className: (0, _classnames2.default)(selectRowClass, className)
+      };
+
+      return _react2.default.createElement(
+        'tr',
+        _extends({}, trCss, {
+          onMouseOver: this.rowMouseOver,
+          onMouseOut: this.rowMouseOut,
+          onClick: this.rowClick,
+          onDoubleClick: this.rowDoubleClick }),
+        this.props.children
+      );
+    }
+  }]);
+
+  return TableRow;
+}(_react.Component);
+
+TableRow.propTypes = {
+  index: _propTypes2.default.number,
+  row: _propTypes2.default.any,
+  style: _propTypes2.default.any,
+  isSelected: _propTypes2.default.bool,
+  enableCellEdit: _propTypes2.default.bool,
+  onRowClick: _propTypes2.default.func,
+  onRowDoubleClick: _propTypes2.default.func,
+  onSelectRow: _propTypes2.default.func,
+  onExpandRow: _propTypes2.default.func,
+  onRowMouseOut: _propTypes2.default.func,
+  onRowMouseOver: _propTypes2.default.func,
+  unselectableRow: _propTypes2.default.bool
+};
+TableRow.defaultProps = {
+  onRowClick: undefined,
+  onRowDoubleClick: undefined
+};
+var _default = TableRow;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(TableRow, 'TableRow', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/TableRow.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/TableRow.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/csv_export_util.js

@@ -0,0 +1,111 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _util = require('./util');
+
+var _util2 = _interopRequireDefault(_util);
+
+var _Const = require('./Const');
+
+var _Const2 = _interopRequireDefault(_Const);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* eslint block-scoped-var: 0 */
+/* eslint vars-on-top: 0 */
+/* eslint no-var: 0 */
+/* eslint no-unused-vars: 0 */
+if (_util2.default.canUseDOM()) {
+  var filesaver = require('./filesaver');
+  var saveAs = filesaver.saveAs;
+}
+
+function toString(data, keys, separator, excludeCSVHeader) {
+  var dataString = '';
+  if (data.length === 0) return dataString;
+
+  var headCells = [];
+  var rowCount = 0;
+  keys.forEach(function (key) {
+    if (key.row > rowCount) {
+      rowCount = key.row;
+    }
+    // rowCount += (key.rowSpan + key.colSpan - 1);
+    for (var index = 0; index < key.colSpan; index++) {
+      headCells.push(key);
+    }
+  });
+
+  var firstRow = excludeCSVHeader ? 1 : 0;
+
+  var _loop = function _loop(i) {
+    dataString += headCells.map(function (x) {
+      if (x.row + (x.rowSpan - 1) === i) {
+        return '"' + x.header + '"';
+      }
+      if (x.row === i && x.rowSpan > 1) {
+        return '';
+      }
+    }).filter(function (key) {
+      return typeof key !== 'undefined';
+    }).join(separator) + '\n';
+  };
+
+  for (var i = firstRow; i <= rowCount; i++) {
+    _loop(i);
+  }
+
+  keys = keys.filter(function (key) {
+    return key.field !== undefined;
+  });
+
+  data.map(function (row) {
+    keys.map(function (col, i) {
+      var field = col.field,
+          format = col.format,
+          extraData = col.extraData,
+          type = col.type;
+
+      var value = typeof format !== 'undefined' ? format(row[field], row, extraData) : row[field];
+      value = type === _Const2.default.CSV_NUMBER_TYPE ? Number(value) : '"' + value + '"';
+      var cell = typeof value !== 'undefined' ? value : '';
+      dataString += cell;
+      if (i + 1 < keys.length) dataString += separator;
+    });
+
+    dataString += '\n';
+  });
+
+  return dataString;
+}
+
+var exportCSV = function exportCSV(data, keys, filename, separator, noAutoBOM, excludeCSVHeader) {
+  var dataString = toString(data, keys, separator, excludeCSVHeader);
+  if (typeof window !== 'undefined') {
+    noAutoBOM = noAutoBOM === undefined ? true : noAutoBOM;
+    saveAs(new Blob(['\uFEFF', dataString], { type: 'text/plain;charset=utf-8' }), filename, noAutoBOM);
+  }
+};
+
+var _default = exportCSV;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(saveAs, 'saveAs', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/csv_export_util.js');
+
+  __REACT_HOT_LOADER__.register(toString, 'toString', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/csv_export_util.js');
+
+  __REACT_HOT_LOADER__.register(exportCSV, 'exportCSV', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/csv_export_util.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/csv_export_util.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/filesaver.js

@@ -0,0 +1,193 @@
+"use strict";
+
+/* FileSaver.js
+ * A saveAs() FileSaver implementation.
+ * 1.3.2
+ * 2016-06-16 18:25:19
+ *
+ * By Eli Grey, http://eligrey.com
+ * License: MIT
+ *   See https://github.com/eligrey/FileSaver.js/blob/master/LICENSE.md
+ */
+
+/*global self */
+/*jslint bitwise: true, indent: 4, laxbreak: true, laxcomma: true, smarttabs: true, plusplus: true */
+
+/*! @source http://purl.eligrey.com/github/FileSaver.js/blob/master/FileSaver.js */
+
+var saveAs = saveAs || function (view) {
+	"use strict";
+	// IE <10 is explicitly unsupported
+
+	if (typeof view === "undefined" || typeof navigator !== "undefined" && /MSIE [1-9]\./.test(navigator.userAgent)) {
+		return;
+	}
+	var doc = view.document
+	// only get URL when necessary in case Blob.js hasn't overridden it yet
+	,
+	    get_URL = function get_URL() {
+		return view.URL || view.webkitURL || view;
+	},
+	    save_link = doc.createElementNS("http://www.w3.org/1999/xhtml", "a"),
+	    can_use_save_link = "download" in save_link,
+	    click = function click(node) {
+		var event = new MouseEvent("click");
+		node.dispatchEvent(event);
+	},
+	    is_safari = /constructor/i.test(view.HTMLElement) || view.safari,
+	    is_chrome_ios = /CriOS\/[\d]+/.test(navigator.userAgent),
+	    throw_outside = function throw_outside(ex) {
+		(view.setImmediate || view.setTimeout)(function () {
+			throw ex;
+		}, 0);
+	},
+	    force_saveable_type = "application/octet-stream"
+	// the Blob API is fundamentally broken as there is no "downloadfinished" event to subscribe to
+	,
+	    arbitrary_revoke_timeout = 1000 * 40 // in ms
+	,
+	    revoke = function revoke(file) {
+		var revoker = function revoker() {
+			if (typeof file === "string") {
+				// file is an object URL
+				get_URL().revokeObjectURL(file);
+			} else {
+				// file is a File
+				file.remove();
+			}
+		};
+		setTimeout(revoker, arbitrary_revoke_timeout);
+	},
+	    dispatch = function dispatch(filesaver, event_types, event) {
+		event_types = [].concat(event_types);
+		var i = event_types.length;
+		while (i--) {
+			var listener = filesaver["on" + event_types[i]];
+			if (typeof listener === "function") {
+				try {
+					listener.call(filesaver, event || filesaver);
+				} catch (ex) {
+					throw_outside(ex);
+				}
+			}
+		}
+	},
+	    auto_bom = function auto_bom(blob) {
+		// prepend BOM for UTF-8 XML and text/* types (including HTML)
+		// note: your browser will automatically convert UTF-16 U+FEFF to EF BB BF
+		if (/^\s*(?:text\/\S*|application\/xml|\S*\/\S*\+xml)\s*;.*charset\s*=\s*utf-8/i.test(blob.type)) {
+			return new Blob([String.fromCharCode(0xFEFF), blob], { type: blob.type });
+		}
+		return blob;
+	},
+	    FileSaver = function FileSaver(blob, name, no_auto_bom) {
+		if (!no_auto_bom) {
+			blob = auto_bom(blob);
+		}
+		// First try a.download, then web filesystem, then object URLs
+		var filesaver = this,
+		    type = blob.type,
+		    force = type === force_saveable_type,
+		    object_url,
+		    dispatch_all = function dispatch_all() {
+			dispatch(filesaver, "writestart progress write writeend".split(" "));
+		}
+		// on any filesys errors revert to saving with object URLs
+		,
+		    fs_error = function fs_error() {
+			if ((is_chrome_ios || force && is_safari) && view.FileReader) {
+				// Safari doesn't allow downloading of blob urls
+				var reader = new FileReader();
+				reader.onloadend = function () {
+					var url = is_chrome_ios ? reader.result : reader.result.replace(/^data:[^;]*;/, 'data:attachment/file;');
+					var popup = view.open(url, '_blank');
+					if (!popup) view.location.href = url;
+					url = undefined; // release reference before dispatching
+					filesaver.readyState = filesaver.DONE;
+					dispatch_all();
+				};
+				reader.readAsDataURL(blob);
+				filesaver.readyState = filesaver.INIT;
+				return;
+			}
+			// don't create more object URLs than needed
+			if (!object_url) {
+				object_url = get_URL().createObjectURL(blob);
+			}
+			if (force) {
+				view.location.href = object_url;
+			} else {
+				var opened = view.open(object_url, "_blank");
+				if (!opened) {
+					// Apple does not allow window.open, see https://developer.apple.com/library/safari/documentation/Tools/Conceptual/SafariExtensionGuide/WorkingwithWindowsandTabs/WorkingwithWindowsandTabs.html
+					view.location.href = object_url;
+				}
+			}
+			filesaver.readyState = filesaver.DONE;
+			dispatch_all();
+			revoke(object_url);
+		};
+		filesaver.readyState = filesaver.INIT;
+
+		if (can_use_save_link) {
+			object_url = get_URL().createObjectURL(blob);
+			setTimeout(function () {
+				save_link.href = object_url;
+				save_link.download = name;
+				click(save_link);
+				dispatch_all();
+				revoke(object_url);
+				filesaver.readyState = filesaver.DONE;
+			});
+			return;
+		}
+
+		fs_error();
+	},
+	    FS_proto = FileSaver.prototype,
+	    saveAs = function saveAs(blob, name, no_auto_bom) {
+		return new FileSaver(blob, name || blob.name || "download", no_auto_bom);
+	};
+	// IE 10+ (native saveAs)
+	if (typeof navigator !== "undefined" && navigator.msSaveOrOpenBlob) {
+		return function (blob, name, no_auto_bom) {
+			name = name || blob.name || "download";
+
+			if (!no_auto_bom) {
+				blob = auto_bom(blob);
+			}
+			return navigator.msSaveOrOpenBlob(blob, name);
+		};
+	}
+
+	FS_proto.abort = function () {};
+	FS_proto.readyState = FS_proto.INIT = 0;
+	FS_proto.WRITING = 1;
+	FS_proto.DONE = 2;
+
+	FS_proto.error = FS_proto.onwritestart = FS_proto.onprogress = FS_proto.onwrite = FS_proto.onabort = FS_proto.onerror = FS_proto.onwriteend = null;
+
+	return saveAs;
+}(typeof self !== "undefined" && self || typeof window !== "undefined" && window || undefined.content);
+// `self` is undefined in Firefox for Android content script context
+// while `this` is nsIContentFrameMessageManager
+// with an attribute `content` that corresponds to the window
+
+if (typeof module !== "undefined" && module.exports) {
+	module.exports.saveAs = saveAs;
+} else if (typeof define !== "undefined" && define !== null && define.amd !== null) {
+	define("FileSaver.js", function () {
+		return saveAs;
+	});
+}
+;
+
+var _temp = function () {
+	if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+		return;
+	}
+
+	__REACT_HOT_LOADER__.register(saveAs, "saveAs", "/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/filesaver.js");
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/filters/Date.js

@@ -0,0 +1,223 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _Const = require('../Const');
+
+var _Const2 = _interopRequireDefault(_Const);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; } /* eslint quotes: 0 */
+/* eslint max-len: 0 */
+
+
+var legalComparators = ['=', '>', '>=', '<', '<=', '!='];
+
+function dateParser(d) {
+  return d.getFullYear() + '-' + ("0" + (d.getMonth() + 1)).slice(-2) + '-' + ("0" + d.getDate()).slice(-2);
+}
+
+var DateFilter = function (_Component) {
+  _inherits(DateFilter, _Component);
+
+  function DateFilter(props) {
+    _classCallCheck(this, DateFilter);
+
+    var _this = _possibleConstructorReturn(this, (DateFilter.__proto__ || Object.getPrototypeOf(DateFilter)).call(this, props));
+
+    _this.dateComparators = _this.props.dateComparators || legalComparators;
+    _this.filter = _this.filter.bind(_this);
+    _this.onChangeComparator = _this.onChangeComparator.bind(_this);
+    return _this;
+  }
+
+  _createClass(DateFilter, [{
+    key: 'setDefaultDate',
+    value: function setDefaultDate() {
+      var defaultDate = '';
+      var defaultValue = this.props.defaultValue;
+
+      if (defaultValue && defaultValue.date) {
+        // Set the appropriate format for the input type=date, i.e. "YYYY-MM-DD"
+        defaultDate = dateParser(new Date(defaultValue.date));
+      }
+      return defaultDate;
+    }
+  }, {
+    key: 'onChangeComparator',
+    value: function onChangeComparator(event) {
+      var date = this.refs.inputDate.value;
+      var comparator = event.target.value;
+      if (date === '') {
+        return;
+      }
+      date = new Date(date);
+      this.props.filterHandler({ date: date, comparator: comparator }, _Const2.default.FILTER_TYPE.DATE);
+    }
+  }, {
+    key: 'getComparatorOptions',
+    value: function getComparatorOptions() {
+      var optionTags = [];
+      optionTags.push(_react2.default.createElement('option', { key: '-1' }));
+      for (var i = 0; i < this.dateComparators.length; i++) {
+        optionTags.push(_react2.default.createElement(
+          'option',
+          { key: i, value: this.dateComparators[i] },
+          this.dateComparators[i]
+        ));
+      }
+      return optionTags;
+    }
+  }, {
+    key: 'filter',
+    value: function filter(event) {
+      var comparator = this.refs.dateFilterComparator.value;
+      var dateValue = event.target.value;
+      if (dateValue) {
+        this.props.filterHandler({ date: new Date(dateValue), comparator: comparator }, _Const2.default.FILTER_TYPE.DATE);
+      } else {
+        this.props.filterHandler(null, _Const2.default.FILTER_TYPE.DATE);
+      }
+    }
+  }, {
+    key: 'cleanFiltered',
+    value: function cleanFiltered() {
+      var value = this.setDefaultDate();
+      var comparator = this.props.defaultValue ? this.props.defaultValue.comparator : '';
+      this.setState(function () {
+        return { isPlaceholderSelected: value === '' };
+      });
+      this.refs.dateFilterComparator.value = comparator;
+      this.refs.inputDate.value = value;
+      this.props.filterHandler({ date: new Date(value), comparator: comparator }, _Const2.default.FILTER_TYPE.DATE);
+    }
+  }, {
+    key: 'applyFilter',
+    value: function applyFilter(filterDateObj) {
+      var date = filterDateObj.date,
+          comparator = filterDateObj.comparator;
+
+      this.setState(function () {
+        return { isPlaceholderSelected: date === '' };
+      });
+      this.refs.dateFilterComparator.value = comparator;
+      this.refs.inputDate.value = dateParser(date);
+      this.props.filterHandler({ date: date, comparator: comparator }, _Const2.default.FILTER_TYPE.DATE);
+    }
+  }, {
+    key: 'componentDidMount',
+    value: function componentDidMount() {
+      var comparator = this.refs.dateFilterComparator.value;
+      var dateValue = this.refs.inputDate.value;
+      if (comparator && dateValue) {
+        this.props.filterHandler({ date: new Date(dateValue), comparator: comparator }, _Const2.default.FILTER_TYPE.DATE);
+      }
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      var _props = this.props,
+          defaultValue = _props.defaultValue,
+          _props$style = _props.style,
+          date = _props$style.date,
+          comparator = _props$style.comparator;
+
+      return _react2.default.createElement(
+        'div',
+        { className: 'filter date-filter' },
+        _react2.default.createElement(
+          'select',
+          { ref: 'dateFilterComparator',
+            style: comparator,
+            className: 'date-filter-comparator form-control',
+            onChange: this.onChangeComparator,
+            defaultValue: defaultValue ? defaultValue.comparator : '' },
+          this.getComparatorOptions()
+        ),
+        _react2.default.createElement('input', { ref: 'inputDate',
+          className: 'filter date-filter-input form-control',
+          style: date,
+          type: 'date',
+          onChange: this.filter,
+          defaultValue: this.setDefaultDate() })
+      );
+    }
+  }]);
+
+  return DateFilter;
+}(_react.Component);
+
+DateFilter.propTypes = {
+  filterHandler: _propTypes2.default.func.isRequired,
+  defaultValue: _propTypes2.default.shape({
+    date: _propTypes2.default.object,
+    comparator: _propTypes2.default.oneOf(legalComparators)
+  }),
+  style: _propTypes2.default.shape({
+    date: _propTypes2.default.oneOfType([_propTypes2.default.object]),
+    comparator: _propTypes2.default.oneOfType([_propTypes2.default.object])
+  }),
+  /* eslint consistent-return: 0 */
+  dateComparators: function dateComparators(props, propName) {
+    if (!props[propName]) {
+      return;
+    }
+    for (var i = 0; i < props[propName].length; i++) {
+      var comparatorIsValid = false;
+      for (var j = 0; j < legalComparators.length; j++) {
+        if (legalComparators[j] === props[propName][i]) {
+          comparatorIsValid = true;
+          break;
+        }
+      }
+      if (!comparatorIsValid) {
+        return new Error('Date comparator provided is not supported.\n          Use only ' + legalComparators);
+      }
+    }
+  },
+  columnName: _propTypes2.default.any
+};
+
+DateFilter.defaultProps = {
+  style: {
+    date: null,
+    comparator: null
+  }
+};
+
+var _default = DateFilter;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(legalComparators, 'legalComparators', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/filters/Date.js');
+
+  __REACT_HOT_LOADER__.register(dateParser, 'dateParser', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/filters/Date.js');
+
+  __REACT_HOT_LOADER__.register(DateFilter, 'DateFilter', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/filters/Date.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/filters/Date.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/filters/Number.js

@@ -0,0 +1,276 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _classnames = require('classnames');
+
+var _classnames2 = _interopRequireDefault(_classnames);
+
+var _Const = require('../Const');
+
+var _Const2 = _interopRequireDefault(_Const);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 legalComparators = ['=', '>', '>=', '<', '<=', '!='];
+
+var NumberFilter = function (_Component) {
+  _inherits(NumberFilter, _Component);
+
+  function NumberFilter(props) {
+    _classCallCheck(this, NumberFilter);
+
+    var _this = _possibleConstructorReturn(this, (NumberFilter.__proto__ || Object.getPrototypeOf(NumberFilter)).call(this, props));
+
+    _this.numberComparators = _this.props.numberComparators || legalComparators;
+    _this.timeout = null;
+    _this.state = {
+      isPlaceholderSelected: _this.props.defaultValue === undefined || _this.props.defaultValue.number === undefined || _this.props.options && _this.props.options.indexOf(_this.props.defaultValue.number) === -1
+    };
+    _this.onChangeNumber = _this.onChangeNumber.bind(_this);
+    _this.onChangeNumberSet = _this.onChangeNumberSet.bind(_this);
+    _this.onChangeComparator = _this.onChangeComparator.bind(_this);
+    return _this;
+  }
+
+  _createClass(NumberFilter, [{
+    key: 'onChangeNumber',
+    value: function onChangeNumber(event) {
+      var _this2 = this;
+
+      var comparator = this.refs.numberFilterComparator.value;
+      if (comparator === '') {
+        return;
+      }
+      if (this.timeout) {
+        clearTimeout(this.timeout);
+      }
+      var filterValue = event.target.value;
+      this.timeout = setTimeout(function () {
+        _this2.props.filterHandler({ number: filterValue, comparator: comparator }, _Const2.default.FILTER_TYPE.NUMBER);
+      }, this.props.delay);
+    }
+  }, {
+    key: 'onChangeNumberSet',
+    value: function onChangeNumberSet(event) {
+      var comparator = this.refs.numberFilterComparator.value;
+      var value = event.target.value;
+
+      this.setState(function () {
+        return { isPlaceholderSelected: value === '' };
+      });
+      if (comparator === '') {
+        return;
+      }
+      this.props.filterHandler({ number: value, comparator: comparator }, _Const2.default.FILTER_TYPE.NUMBER);
+    }
+  }, {
+    key: 'onChangeComparator',
+    value: function onChangeComparator(event) {
+      var value = this.refs.numberFilter.value;
+      var comparator = event.target.value;
+      if (value === '') {
+        return;
+      }
+      this.props.filterHandler({ number: value, comparator: comparator }, _Const2.default.FILTER_TYPE.NUMBER);
+    }
+  }, {
+    key: 'cleanFiltered',
+    value: function cleanFiltered() {
+      var value = this.props.defaultValue ? this.props.defaultValue.number : '';
+      var comparator = this.props.defaultValue ? this.props.defaultValue.comparator : '';
+      this.setState(function () {
+        return { isPlaceholderSelected: value === '' };
+      });
+      this.refs.numberFilterComparator.value = comparator;
+      this.refs.numberFilter.value = value;
+      this.props.filterHandler({ number: value, comparator: comparator }, _Const2.default.FILTER_TYPE.NUMBER);
+    }
+  }, {
+    key: 'applyFilter',
+    value: function applyFilter(filterObj) {
+      var number = filterObj.number,
+          comparator = filterObj.comparator;
+
+      this.setState(function () {
+        return { isPlaceholderSelected: number === '' };
+      });
+      this.refs.numberFilterComparator.value = comparator;
+      this.refs.numberFilter.value = number;
+      this.props.filterHandler({ number: number, comparator: comparator }, _Const2.default.FILTER_TYPE.NUMBER);
+    }
+  }, {
+    key: 'getComparatorOptions',
+    value: function getComparatorOptions() {
+      var optionTags = [];
+      var withoutEmptyComparatorOption = this.props.withoutEmptyComparatorOption;
+
+      if (!withoutEmptyComparatorOption) {
+        optionTags.push(_react2.default.createElement('option', { key: '-1' }));
+      }
+      for (var i = 0; i < this.numberComparators.length; i++) {
+        optionTags.push(_react2.default.createElement(
+          'option',
+          { key: i, value: this.numberComparators[i] },
+          this.numberComparators[i]
+        ));
+      }
+      return optionTags;
+    }
+  }, {
+    key: 'getNumberOptions',
+    value: function getNumberOptions() {
+      var optionTags = [];
+      var _props = this.props,
+          options = _props.options,
+          withoutEmptyNumberOption = _props.withoutEmptyNumberOption;
+
+      if (!withoutEmptyNumberOption) {
+        optionTags.push(_react2.default.createElement(
+          'option',
+          { key: '-1', value: '' },
+          this.props.placeholder || 'Select ' + this.props.columnName + '...'
+        ));
+      }
+      for (var i = 0; i < options.length; i++) {
+        optionTags.push(_react2.default.createElement(
+          'option',
+          { key: i, value: options[i] },
+          options[i]
+        ));
+      }
+      return optionTags;
+    }
+  }, {
+    key: 'componentDidMount',
+    value: function componentDidMount() {
+      var comparator = this.refs.numberFilterComparator.value;
+      var number = this.refs.numberFilter.value;
+      if (comparator && number) {
+        this.props.filterHandler({ number: number, comparator: comparator }, _Const2.default.FILTER_TYPE.NUMBER);
+      }
+    }
+  }, {
+    key: 'componentWillUnmount',
+    value: function componentWillUnmount() {
+      clearTimeout(this.timeout);
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      var selectClass = (0, _classnames2.default)('select-filter', 'number-filter-input', 'form-control', { 'placeholder-selected': this.state.isPlaceholderSelected });
+
+      return _react2.default.createElement(
+        'div',
+        { className: 'filter number-filter' },
+        _react2.default.createElement(
+          'select',
+          { ref: 'numberFilterComparator',
+            style: this.props.style.comparator,
+            className: 'number-filter-comparator form-control',
+            onChange: this.onChangeComparator,
+            defaultValue: this.props.defaultValue ? this.props.defaultValue.comparator : '' },
+          this.getComparatorOptions()
+        ),
+        this.props.options ? _react2.default.createElement(
+          'select',
+          { ref: 'numberFilter',
+            className: selectClass,
+            onChange: this.onChangeNumberSet,
+            defaultValue: this.props.defaultValue ? this.props.defaultValue.number : '' },
+          this.getNumberOptions()
+        ) : _react2.default.createElement('input', { ref: 'numberFilter',
+          type: 'number',
+          style: this.props.style.number,
+          className: 'number-filter-input form-control',
+          placeholder: this.props.placeholder || 'Enter ' + this.props.columnName + '...',
+          onChange: this.onChangeNumber,
+          defaultValue: this.props.defaultValue ? this.props.defaultValue.number : '' })
+      );
+    }
+  }]);
+
+  return NumberFilter;
+}(_react.Component);
+
+NumberFilter.propTypes = {
+  filterHandler: _propTypes2.default.func.isRequired,
+  options: _propTypes2.default.arrayOf(_propTypes2.default.number),
+  defaultValue: _propTypes2.default.shape({
+    number: _propTypes2.default.number,
+    comparator: _propTypes2.default.oneOf(legalComparators)
+  }),
+  style: _propTypes2.default.shape({
+    number: _propTypes2.default.oneOfType([_propTypes2.default.object]),
+    comparator: _propTypes2.default.oneOfType([_propTypes2.default.object])
+  }),
+  delay: _propTypes2.default.number,
+  /* eslint consistent-return: 0 */
+  numberComparators: function numberComparators(props, propName) {
+    if (!props[propName]) {
+      return;
+    }
+    for (var i = 0; i < props[propName].length; i++) {
+      var comparatorIsValid = false;
+      for (var j = 0; j < legalComparators.length; j++) {
+        if (legalComparators[j] === props[propName][i]) {
+          comparatorIsValid = true;
+          break;
+        }
+      }
+      if (!comparatorIsValid) {
+        return new Error('Number comparator provided is not supported.\n          Use only ' + legalComparators);
+      }
+    }
+  },
+  placeholder: _propTypes2.default.string,
+  columnName: _propTypes2.default.any,
+  withoutEmptyComparatorOption: _propTypes2.default.bool,
+  withoutEmptyNumberOption: _propTypes2.default.bool
+};
+
+NumberFilter.defaultProps = {
+  delay: _Const2.default.FILTER_DELAY,
+  withoutEmptyComparatorOption: false,
+  withoutEmptyNumberOption: false,
+  style: {
+    number: null,
+    comparator: null
+  }
+};
+
+var _default = NumberFilter;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(legalComparators, 'legalComparators', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/filters/Number.js');
+
+  __REACT_HOT_LOADER__.register(NumberFilter, 'NumberFilter', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/filters/Number.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/filters/Number.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/filters/Regex.js

@@ -0,0 +1,130 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _Const = require('../Const');
+
+var _Const2 = _interopRequireDefault(_Const);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 RegexFilter = function (_Component) {
+  _inherits(RegexFilter, _Component);
+
+  function RegexFilter(props) {
+    _classCallCheck(this, RegexFilter);
+
+    var _this = _possibleConstructorReturn(this, (RegexFilter.__proto__ || Object.getPrototypeOf(RegexFilter)).call(this, props));
+
+    _this.filter = _this.filter.bind(_this);
+    _this.timeout = null;
+    return _this;
+  }
+
+  _createClass(RegexFilter, [{
+    key: 'filter',
+    value: function filter(event) {
+      var _this2 = this;
+
+      if (this.timeout) {
+        clearTimeout(this.timeout);
+      }
+      var filterValue = event.target.value;
+      this.timeout = setTimeout(function () {
+        _this2.props.filterHandler(filterValue, _Const2.default.FILTER_TYPE.REGEX);
+      }, this.props.delay);
+    }
+  }, {
+    key: 'cleanFiltered',
+    value: function cleanFiltered() {
+      var value = this.props.defaultValue ? this.props.defaultValue : '';
+      this.refs.inputText.value = value;
+      this.props.filterHandler(value, _Const2.default.FILTER_TYPE.TEXT);
+    }
+  }, {
+    key: 'applyFilter',
+    value: function applyFilter(filterRegx) {
+      this.refs.inputText.value = filterRegx;
+      this.props.filterHandler(filterRegx, _Const2.default.FILTER_TYPE.REGEX);
+    }
+  }, {
+    key: 'componentDidMount',
+    value: function componentDidMount() {
+      var value = this.refs.inputText.value;
+      if (value) {
+        this.props.filterHandler(value, _Const2.default.FILTER_TYPE.REGEX);
+      }
+    }
+  }, {
+    key: 'componentWillUnmount',
+    value: function componentWillUnmount() {
+      clearTimeout(this.timeout);
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      var _props = this.props,
+          defaultValue = _props.defaultValue,
+          placeholder = _props.placeholder,
+          columnName = _props.columnName,
+          style = _props.style;
+
+      return _react2.default.createElement('input', { ref: 'inputText',
+        className: 'filter text-filter form-control',
+        type: 'text',
+        style: style,
+        onChange: this.filter,
+        placeholder: placeholder || 'Enter Regex for ' + columnName + '...',
+        defaultValue: defaultValue ? defaultValue : '' });
+    }
+  }]);
+
+  return RegexFilter;
+}(_react.Component);
+
+RegexFilter.propTypes = {
+  filterHandler: _propTypes2.default.func.isRequired,
+  defaultValue: _propTypes2.default.string,
+  delay: _propTypes2.default.number,
+  placeholder: _propTypes2.default.string,
+  columnName: _propTypes2.default.any,
+  style: _propTypes2.default.oneOfType([_propTypes2.default.object])
+};
+
+RegexFilter.defaultProps = {
+  delay: _Const2.default.FILTER_DELAY
+};
+
+var _default = RegexFilter;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(RegexFilter, 'RegexFilter', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/filters/Regex.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/filters/Regex.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/filters/Select.js

@@ -0,0 +1,195 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _classnames = require('classnames');
+
+var _classnames2 = _interopRequireDefault(_classnames);
+
+var _Const = require('../Const');
+
+var _Const2 = _interopRequireDefault(_Const);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+function optionsEquals(options1, options2) {
+  var keys = Object.keys(options1);
+  for (var k in keys) {
+    if (options1[k] !== options2[k]) {
+      return false;
+    }
+  }
+  return Object.keys(options1).length === Object.keys(options2).length;
+}
+
+var SelectFilter = function (_Component) {
+  _inherits(SelectFilter, _Component);
+
+  function SelectFilter(props) {
+    _classCallCheck(this, SelectFilter);
+
+    var _this = _possibleConstructorReturn(this, (SelectFilter.__proto__ || Object.getPrototypeOf(SelectFilter)).call(this, props));
+
+    _this.filter = _this.filter.bind(_this);
+    _this.state = {
+      isPlaceholderSelected: _this.props.defaultValue === undefined || !_this.props.options.hasOwnProperty(_this.props.defaultValue)
+    };
+    return _this;
+  }
+
+  _createClass(SelectFilter, [{
+    key: 'componentWillReceiveProps',
+    value: function componentWillReceiveProps() {
+      var currentSelectValue = this.refs.selectInput.value;
+      var isPlaceholderSelected = !currentSelectValue || currentSelectValue === '';
+      this.setState(function () {
+        return {
+          isPlaceholderSelected: isPlaceholderSelected
+        };
+      });
+    }
+  }, {
+    key: 'componentDidUpdate',
+    value: function componentDidUpdate(prevProps) {
+      var needFilter = false;
+      if (this.props.defaultValue !== prevProps.defaultValue) {
+        needFilter = true;
+      } else if (!optionsEquals(this.props.options, prevProps.options)) {
+        needFilter = true;
+      }
+      if (needFilter) {
+        var value = this.refs.selectInput.value;
+        if (value) {
+          this.props.filterHandler(value, _Const2.default.FILTER_TYPE.SELECT);
+        }
+      }
+    }
+  }, {
+    key: 'filter',
+    value: function filter(event) {
+      var value = event.target.value;
+
+      this.setState(function () {
+        return { isPlaceholderSelected: value === '' };
+      });
+      this.props.filterHandler(value, _Const2.default.FILTER_TYPE.SELECT);
+    }
+  }, {
+    key: 'cleanFiltered',
+    value: function cleanFiltered() {
+      var value = this.props.defaultValue !== undefined ? this.props.defaultValue : '';
+      this.setState(function () {
+        return { isPlaceholderSelected: value === '' };
+      });
+      this.refs.selectInput.value = value;
+      this.props.filterHandler(value, _Const2.default.FILTER_TYPE.SELECT);
+    }
+  }, {
+    key: 'applyFilter',
+    value: function applyFilter(filterOption) {
+      filterOption = filterOption + '';
+      this.setState(function () {
+        return { isPlaceholderSelected: filterOption === '' };
+      });
+      this.refs.selectInput.value = filterOption;
+      this.props.filterHandler(filterOption, _Const2.default.FILTER_TYPE.SELECT);
+    }
+  }, {
+    key: 'getOptions',
+    value: function getOptions() {
+      var optionTags = [];
+      var _props = this.props,
+          options = _props.options,
+          placeholder = _props.placeholder,
+          columnName = _props.columnName,
+          selectText = _props.selectText,
+          withoutEmptyOption = _props.withoutEmptyOption;
+
+      var selectTextValue = selectText !== undefined ? selectText : 'Select';
+      if (!withoutEmptyOption) {
+        optionTags.push(_react2.default.createElement(
+          'option',
+          { key: '-1', value: '' },
+          placeholder || selectTextValue + ' ' + columnName + '...'
+        ));
+      }
+      Object.keys(options).map(function (key) {
+        optionTags.push(_react2.default.createElement(
+          'option',
+          { key: key, value: key },
+          options[key] + ''
+        ));
+      });
+      return optionTags;
+    }
+  }, {
+    key: 'componentDidMount',
+    value: function componentDidMount() {
+      var value = this.refs.selectInput.value;
+      if (value) {
+        this.props.filterHandler(value, _Const2.default.FILTER_TYPE.SELECT);
+      }
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      var selectClass = (0, _classnames2.default)('filter', 'select-filter', 'form-control', { 'placeholder-selected': this.state.isPlaceholderSelected });
+
+      return _react2.default.createElement(
+        'select',
+        { ref: 'selectInput',
+          style: this.props.style,
+          className: selectClass,
+          onChange: this.filter,
+          defaultValue: this.props.defaultValue !== undefined ? this.props.defaultValue : '' },
+        this.getOptions()
+      );
+    }
+  }]);
+
+  return SelectFilter;
+}(_react.Component);
+
+SelectFilter.propTypes = {
+  filterHandler: _propTypes2.default.func.isRequired,
+  options: _propTypes2.default.object.isRequired,
+  placeholder: _propTypes2.default.string,
+  columnName: _propTypes2.default.any,
+  style: _propTypes2.default.oneOfType([_propTypes2.default.object])
+};
+
+var _default = SelectFilter;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(optionsEquals, 'optionsEquals', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/filters/Select.js');
+
+  __REACT_HOT_LOADER__.register(SelectFilter, 'SelectFilter', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/filters/Select.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/filters/Select.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/filters/Text.js

@@ -0,0 +1,146 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _Const = require('../Const');
+
+var _Const2 = _interopRequireDefault(_Const);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 TextFilter = function (_Component) {
+  _inherits(TextFilter, _Component);
+
+  function TextFilter(props) {
+    _classCallCheck(this, TextFilter);
+
+    var _this = _possibleConstructorReturn(this, (TextFilter.__proto__ || Object.getPrototypeOf(TextFilter)).call(this, props));
+
+    _this.filter = _this.filter.bind(_this);
+    _this.timeout = null;
+    _this.state = {
+      value: _this.props.defaultValue || ''
+    };
+    return _this;
+  }
+
+  _createClass(TextFilter, [{
+    key: 'filter',
+    value: function filter(event) {
+      var _this2 = this;
+
+      if (this.timeout) {
+        clearTimeout(this.timeout);
+      }
+      var filterValue = event.target.value;
+      this.setState(function () {
+        return { value: filterValue };
+      });
+      this.timeout = setTimeout(function () {
+        _this2.props.filterHandler(filterValue, _Const2.default.FILTER_TYPE.TEXT);
+      }, this.props.delay);
+    }
+  }, {
+    key: 'cleanFiltered',
+    value: function cleanFiltered() {
+      var value = this.props.defaultValue ? this.props.defaultValue : '';
+      this.setState(function () {
+        return { value: value };
+      });
+      this.props.filterHandler(value, _Const2.default.FILTER_TYPE.TEXT);
+    }
+  }, {
+    key: 'applyFilter',
+    value: function applyFilter(filterText) {
+      this.setState(function () {
+        return { value: filterText };
+      });
+      this.props.filterHandler(filterText, _Const2.default.FILTER_TYPE.TEXT);
+    }
+  }, {
+    key: 'componentDidMount',
+    value: function componentDidMount() {
+      var defaultValue = this.refs.inputText.value;
+      if (defaultValue) {
+        this.props.filterHandler(defaultValue, _Const2.default.FILTER_TYPE.TEXT);
+      }
+    }
+  }, {
+    key: 'componentWillReceiveProps',
+    value: function componentWillReceiveProps(nextProps) {
+      if (nextProps.defaultValue !== this.props.defaultValue) {
+        this.applyFilter(nextProps.defaultValue || '');
+      }
+    }
+  }, {
+    key: 'componentWillUnmount',
+    value: function componentWillUnmount() {
+      clearTimeout(this.timeout);
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      var _props = this.props,
+          placeholder = _props.placeholder,
+          columnName = _props.columnName,
+          style = _props.style;
+
+      return _react2.default.createElement('input', { ref: 'inputText',
+        className: 'filter text-filter form-control',
+        type: 'text',
+        style: style,
+        onChange: this.filter,
+        placeholder: placeholder || 'Enter ' + columnName + '...',
+        value: this.state.value });
+    }
+  }]);
+
+  return TextFilter;
+}(_react.Component);
+
+TextFilter.propTypes = {
+  filterHandler: _propTypes2.default.func.isRequired,
+  defaultValue: _propTypes2.default.string,
+  delay: _propTypes2.default.number,
+  placeholder: _propTypes2.default.string,
+  columnName: _propTypes2.default.any,
+  style: _propTypes2.default.oneOfType([_propTypes2.default.object])
+};
+
+TextFilter.defaultProps = {
+  delay: _Const2.default.FILTER_DELAY
+};
+
+var _default = TextFilter;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(TextFilter, 'TextFilter', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/filters/Text.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/filters/Text.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/index.js

@@ -0,0 +1,98 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SizePerPageDropDown = exports.ButtonGroup = exports.SearchField = exports.ClearSearchButton = exports.ExportCSVButton = exports.ShowSelectedOnlyButton = exports.DeleteButton = exports.InsertButton = exports.InsertModalFooter = exports.InsertModalBody = exports.InsertModalHeader = exports.TableHeaderColumn = exports.BootstrapTable = undefined;
+
+var _BootstrapTable = require('./BootstrapTable');
+
+var _BootstrapTable2 = _interopRequireDefault(_BootstrapTable);
+
+var _TableHeaderColumn = require('./TableHeaderColumn');
+
+var _TableHeaderColumn2 = _interopRequireDefault(_TableHeaderColumn);
+
+var _InsertModalHeader = require('./toolbar/InsertModalHeader');
+
+var _InsertModalHeader2 = _interopRequireDefault(_InsertModalHeader);
+
+var _InsertModalBody = require('./toolbar/InsertModalBody');
+
+var _InsertModalBody2 = _interopRequireDefault(_InsertModalBody);
+
+var _InsertModalFooter = require('./toolbar/InsertModalFooter');
+
+var _InsertModalFooter2 = _interopRequireDefault(_InsertModalFooter);
+
+var _InsertButton = require('./toolbar/InsertButton');
+
+var _InsertButton2 = _interopRequireDefault(_InsertButton);
+
+var _DeleteButton = require('./toolbar/DeleteButton');
+
+var _DeleteButton2 = _interopRequireDefault(_DeleteButton);
+
+var _ExportCSVButton = require('./toolbar/ExportCSVButton');
+
+var _ExportCSVButton2 = _interopRequireDefault(_ExportCSVButton);
+
+var _ShowSelectedOnlyButton = require('./toolbar/ShowSelectedOnlyButton');
+
+var _ShowSelectedOnlyButton2 = _interopRequireDefault(_ShowSelectedOnlyButton);
+
+var _ClearSearchButton = require('./toolbar/ClearSearchButton');
+
+var _ClearSearchButton2 = _interopRequireDefault(_ClearSearchButton);
+
+var _SearchField = require('./toolbar/SearchField');
+
+var _SearchField2 = _interopRequireDefault(_SearchField);
+
+var _ButtonGroup = require('./toolbar/ButtonGroup');
+
+var _ButtonGroup2 = _interopRequireDefault(_ButtonGroup);
+
+var _SizePerPageDropDown = require('./pagination/SizePerPageDropDown');
+
+var _SizePerPageDropDown2 = _interopRequireDefault(_SizePerPageDropDown);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+if (typeof window !== 'undefined') {
+  window.BootstrapTable = _BootstrapTable2.default;
+  window.TableHeaderColumn = _TableHeaderColumn2.default;
+  window.InsertModalHeader = _InsertModalHeader2.default;
+  window.InsertModalBody = _InsertModalBody2.default;
+  window.InsertModalFooter = _InsertModalFooter2.default;
+  window.InsertButton = _InsertButton2.default;
+  window.DeleteButton = _DeleteButton2.default;
+  window.ShowSelectedOnlyButton = _ShowSelectedOnlyButton2.default;
+  window.ExportCSVButton = _ExportCSVButton2.default;
+  window.ClearSearchButton = _ClearSearchButton2.default;
+  window.SearchField = _SearchField2.default;
+  window.ButtonGroup = _ButtonGroup2.default;
+  window.SizePerPageDropDown = _SizePerPageDropDown2.default;
+}
+exports.BootstrapTable = _BootstrapTable2.default;
+exports.TableHeaderColumn = _TableHeaderColumn2.default;
+exports.InsertModalHeader = _InsertModalHeader2.default;
+exports.InsertModalBody = _InsertModalBody2.default;
+exports.InsertModalFooter = _InsertModalFooter2.default;
+exports.InsertButton = _InsertButton2.default;
+exports.DeleteButton = _DeleteButton2.default;
+exports.ShowSelectedOnlyButton = _ShowSelectedOnlyButton2.default;
+exports.ExportCSVButton = _ExportCSVButton2.default;
+exports.ClearSearchButton = _ClearSearchButton2.default;
+exports.SearchField = _SearchField2.default;
+exports.ButtonGroup = _ButtonGroup2.default;
+exports.SizePerPageDropDown = _SizePerPageDropDown2.default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/pagination/PageButton.js

@@ -0,0 +1,102 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _classnames = require('classnames');
+
+var _classnames2 = _interopRequireDefault(_classnames);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 PageButton = function (_Component) {
+  _inherits(PageButton, _Component);
+
+  function PageButton(props) {
+    _classCallCheck(this, PageButton);
+
+    var _this = _possibleConstructorReturn(this, (PageButton.__proto__ || Object.getPrototypeOf(PageButton)).call(this, props));
+
+    _this.pageBtnClick = function () {
+      return _this.__pageBtnClick__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    return _this;
+  }
+
+  _createClass(PageButton, [{
+    key: '__pageBtnClick__REACT_HOT_LOADER__',
+    value: function __pageBtnClick__REACT_HOT_LOADER__() {
+      return this.__pageBtnClick__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__pageBtnClick__REACT_HOT_LOADER__',
+    value: function __pageBtnClick__REACT_HOT_LOADER__(e) {
+      e.preventDefault();
+      this.props.changePage(e.currentTarget.textContent);
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      var classes = (0, _classnames2.default)({
+        'active': this.props.active,
+        'disabled': this.props.disable,
+        'hidden': this.props.hidden,
+        'page-item': true
+      });
+      return _react2.default.createElement(
+        'li',
+        { className: classes, title: this.props.title },
+        _react2.default.createElement(
+          'a',
+          { href: '#', onClick: this.pageBtnClick, className: 'page-link' },
+          this.props.children
+        )
+      );
+    }
+  }]);
+
+  return PageButton;
+}(_react.Component);
+
+PageButton.propTypes = {
+  title: _propTypes2.default.string,
+  changePage: _propTypes2.default.func,
+  active: _propTypes2.default.bool,
+  disable: _propTypes2.default.bool,
+  hidden: _propTypes2.default.bool,
+  children: _propTypes2.default.node
+};
+
+var _default = PageButton;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(PageButton, 'PageButton', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/pagination/PageButton.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/pagination/PageButton.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/pagination/PaginationList.js

@@ -0,0 +1,458 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _classnames = require('classnames');
+
+var _classnames2 = _interopRequireDefault(_classnames);
+
+var _PageButton = require('./PageButton.js');
+
+var _PageButton2 = _interopRequireDefault(_PageButton);
+
+var _SizePerPageDropDown = require('./SizePerPageDropDown');
+
+var _SizePerPageDropDown2 = _interopRequireDefault(_SizePerPageDropDown);
+
+var _Const = require('../Const');
+
+var _Const2 = _interopRequireDefault(_Const);
+
+var _util = require('../util');
+
+var _util2 = _interopRequireDefault(_util);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 PaginationList = function (_Component) {
+  _inherits(PaginationList, _Component);
+
+  function PaginationList(props) {
+    _classCallCheck(this, PaginationList);
+
+    var _this = _possibleConstructorReturn(this, (PaginationList.__proto__ || Object.getPrototypeOf(PaginationList)).call(this, props));
+
+    _this.changePage = function () {
+      return _this.__changePage__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.changeSizePerPage = function () {
+      return _this.__changeSizePerPage__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.toggleDropDown = function () {
+      return _this.__toggleDropDown__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.closeDropDown = function () {
+      return _this.__closeDropDown__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.state = {
+      open: _this.props.open
+    };
+    return _this;
+  }
+
+  _createClass(PaginationList, [{
+    key: '__closeDropDown__REACT_HOT_LOADER__',
+    value: function __closeDropDown__REACT_HOT_LOADER__() {
+      return this.__closeDropDown__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__toggleDropDown__REACT_HOT_LOADER__',
+    value: function __toggleDropDown__REACT_HOT_LOADER__() {
+      return this.__toggleDropDown__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__changeSizePerPage__REACT_HOT_LOADER__',
+    value: function __changeSizePerPage__REACT_HOT_LOADER__() {
+      return this.__changeSizePerPage__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__changePage__REACT_HOT_LOADER__',
+    value: function __changePage__REACT_HOT_LOADER__() {
+      return this.__changePage__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: 'componentWillReceiveProps',
+    value: function componentWillReceiveProps() {
+      var keepSizePerPageState = this.props.keepSizePerPageState;
+
+      if (!keepSizePerPageState) {
+        this.closeDropDown();
+      }
+    }
+  }, {
+    key: '__changePage__REACT_HOT_LOADER__',
+    value: function __changePage__REACT_HOT_LOADER__(page) {
+      var _props = this.props,
+          pageStartIndex = _props.pageStartIndex,
+          prePage = _props.prePage,
+          currPage = _props.currPage,
+          nextPage = _props.nextPage,
+          lastPage = _props.lastPage,
+          firstPage = _props.firstPage,
+          sizePerPage = _props.sizePerPage,
+          keepSizePerPageState = _props.keepSizePerPageState;
+
+
+      if (page === prePage) {
+        page = currPage - 1 < pageStartIndex ? pageStartIndex : currPage - 1;
+      } else if (page === nextPage) {
+        page = currPage + 1 > this.lastPage ? this.lastPage : currPage + 1;
+      } else if (page === lastPage) {
+        page = this.lastPage;
+      } else if (page === firstPage) {
+        page = pageStartIndex;
+      } else {
+        page = parseInt(page, 10);
+      }
+
+      if (keepSizePerPageState) {
+        this.closeDropDown();
+      }
+
+      if (page !== currPage) {
+        this.props.changePage(page, sizePerPage);
+      }
+    }
+  }, {
+    key: '__changeSizePerPage__REACT_HOT_LOADER__',
+    value: function __changeSizePerPage__REACT_HOT_LOADER__(pageNum) {
+      var selectSize = typeof pageNum === 'string' ? parseInt(pageNum, 10) : pageNum;
+      var currPage = this.props.currPage;
+
+      if (selectSize !== this.props.sizePerPage) {
+        this.totalPages = Math.ceil(this.props.dataSize / selectSize);
+        this.lastPage = this.props.pageStartIndex + this.totalPages - 1;
+        if (currPage > this.lastPage) currPage = this.lastPage;
+        this.props.changePage(currPage, selectSize);
+        if (this.props.onSizePerPageList) {
+          this.props.onSizePerPageList(selectSize);
+        }
+      }
+
+      this.closeDropDown();
+    }
+  }, {
+    key: '__toggleDropDown__REACT_HOT_LOADER__',
+    value: function __toggleDropDown__REACT_HOT_LOADER__() {
+      var _this2 = this;
+
+      this.setState(function () {
+        return {
+          open: !_this2.state.open
+        };
+      });
+    }
+  }, {
+    key: '__closeDropDown__REACT_HOT_LOADER__',
+    value: function __closeDropDown__REACT_HOT_LOADER__() {
+      this.setState(function () {
+        return {
+          open: false
+        };
+      });
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      var _props2 = this.props,
+          currPage = _props2.currPage,
+          dataSize = _props2.dataSize,
+          sizePerPage = _props2.sizePerPage,
+          sizePerPageList = _props2.sizePerPageList,
+          paginationShowsTotal = _props2.paginationShowsTotal,
+          pageStartIndex = _props2.pageStartIndex,
+          paginationPanel = _props2.paginationPanel,
+          hidePageListOnlyOnePage = _props2.hidePageListOnlyOnePage;
+
+      this.totalPages = Math.ceil(dataSize / sizePerPage);
+      this.lastPage = this.props.pageStartIndex + this.totalPages - 1;
+      var pageBtns = this.makePage(_util2.default.isFunction(paginationPanel));
+      var dropdown = this.makeDropDown();
+
+      var offset = Math.abs(_Const2.default.PAGE_START_INDEX - pageStartIndex);
+      var start = (currPage - pageStartIndex) * sizePerPage;
+      start = dataSize === 0 ? 0 : start + 1;
+      var to = Math.min(sizePerPage * (currPage + offset) - 1, dataSize);
+      if (to >= dataSize) to--;
+      var total = paginationShowsTotal ? _react2.default.createElement(
+        'span',
+        null,
+        'Showing rows ',
+        start,
+        ' to\xA0',
+        to + 1,
+        ' of\xA0',
+        dataSize
+      ) : null;
+
+      if (_util2.default.isFunction(paginationShowsTotal)) {
+        total = paginationShowsTotal(start, to + 1, dataSize);
+      }
+
+      var content = paginationPanel && paginationPanel({
+        currPage: currPage,
+        sizePerPage: sizePerPage,
+        sizePerPageList: sizePerPageList,
+        pageStartIndex: pageStartIndex,
+        totalPages: this.totalPages,
+        changePage: this.changePage,
+        toggleDropDown: this.toggleDropDown,
+        changeSizePerPage: this.changeSizePerPage,
+        components: {
+          totalText: total,
+          sizePerPageDropdown: dropdown,
+          pageList: pageBtns
+        }
+      });
+
+      var hidePageList = hidePageListOnlyOnePage && this.totalPages === 1 ? 'none' : 'block';
+      return _react2.default.createElement(
+        'div',
+        { className: 'row', style: { marginTop: 15 } },
+        content || [_react2.default.createElement(
+          'div',
+          { key: 'paging-left', className: 'col-md-6 col-xs-6 col-sm-6 col-lg-6' },
+          total,
+          sizePerPageList.length > 1 ? dropdown : null
+        ), _react2.default.createElement(
+          'div',
+          { key: 'paging-right', style: { display: hidePageList },
+            className: 'col-md-6 col-xs-6 col-sm-6 col-lg-6' },
+          pageBtns
+        )]
+      );
+    }
+  }, {
+    key: 'makeDropDown',
+    value: function makeDropDown() {
+      var _this3 = this;
+
+      var dropdown = void 0;
+      var dropdownProps = void 0;
+      var sizePerPageText = '';
+      var _props3 = this.props,
+          sizePerPageDropDown = _props3.sizePerPageDropDown,
+          hideSizePerPage = _props3.hideSizePerPage,
+          sizePerPage = _props3.sizePerPage,
+          sizePerPageList = _props3.sizePerPageList;
+
+      if (sizePerPageDropDown) {
+        dropdown = sizePerPageDropDown({
+          open: this.state.open,
+          hideSizePerPage: hideSizePerPage,
+          currSizePerPage: String(sizePerPage),
+          sizePerPageList: sizePerPageList,
+          toggleDropDown: this.toggleDropDown,
+          changeSizePerPage: this.changeSizePerPage,
+          onBlur: this.closeDropDown
+        });
+        if (dropdown.type.name === _SizePerPageDropDown2.default.name) {
+          dropdownProps = dropdown.props;
+        } else {
+          return dropdown;
+        }
+      }
+
+      if (dropdownProps || !dropdown) {
+        var sizePerPageOptions = sizePerPageList.map(function (_sizePerPage) {
+          var pageText = _sizePerPage.text || _sizePerPage;
+          var pageNum = _sizePerPage.value || _sizePerPage;
+          if (sizePerPage === pageNum) sizePerPageText = pageText;
+          return _react2.default.createElement(
+            'li',
+            { key: pageText, role: 'presentation', className: 'dropdown-item' },
+            _react2.default.createElement(
+              'a',
+              { role: 'menuitem',
+                tabIndex: '-1', href: '#',
+                'data-page': pageNum,
+                onMouseDown: function onMouseDown(e) {
+                  e.preventDefault();
+                  _this3.changeSizePerPage(pageNum);
+                } },
+              pageText
+            )
+          );
+        });
+        dropdown = _react2.default.createElement(_SizePerPageDropDown2.default, _extends({
+          open: this.state.open,
+          hidden: hideSizePerPage,
+          currSizePerPage: String(sizePerPageText),
+          options: sizePerPageOptions,
+          onClick: this.toggleDropDown,
+          onBlur: this.closeDropDown
+        }, dropdownProps));
+      }
+      return dropdown;
+    }
+  }, {
+    key: 'makePage',
+    value: function makePage() {
+      var _this4 = this;
+
+      var isCustomPagingPanel = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+
+      var pages = this.getPages();
+      var isStart = function isStart(page, _ref) {
+        var currPage = _ref.currPage,
+            pageStartIndex = _ref.pageStartIndex,
+            firstPage = _ref.firstPage,
+            prePage = _ref.prePage;
+        return currPage === pageStartIndex && (page === firstPage || page === prePage);
+      };
+      var isEnd = function isEnd(page, _ref2) {
+        var currPage = _ref2.currPage,
+            nextPage = _ref2.nextPage,
+            lastPage = _ref2.lastPage;
+        return currPage === _this4.lastPage && (page === nextPage || page === lastPage);
+      };
+      var pageBtns = pages.filter(function (page) {
+        if (this.props.alwaysShowAllBtns) {
+          return true;
+        }
+        return isStart(page, this.props) || isEnd(page, this.props) ? false : true;
+      }, this).map(function (page) {
+        var isActive = page === this.props.currPage;
+        var isDisabled = isStart(page, this.props) || isEnd(page, this.props) ? true : false;
+        var title = page + '';
+
+        if (page === this.props.nextPage) {
+          title = this.props.nextPageTitle;
+        } else if (page === this.props.prePage) {
+          title = this.props.prePageTitle;
+        } else if (page === this.props.firstPage) {
+          title = this.props.firstPageTitle;
+        } else if (page === this.props.lastPage) {
+          title = this.props.lastPageTitle;
+        }
+
+        return _react2.default.createElement(
+          _PageButton2.default,
+          { key: page,
+            title: title,
+            changePage: this.changePage,
+            active: isActive,
+            disable: isDisabled },
+          page
+        );
+      }, this);
+      var classname = (0, _classnames2.default)(isCustomPagingPanel ? null : 'react-bootstrap-table-page-btns-ul', 'pagination');
+      return _react2.default.createElement(
+        'ul',
+        { className: classname },
+        pageBtns
+      );
+    }
+  }, {
+    key: 'getLastPage',
+    value: function getLastPage() {
+      return this.lastPage;
+    }
+  }, {
+    key: 'getPages',
+    value: function getPages() {
+      var pages = void 0;
+      var endPage = this.totalPages;
+      if (endPage <= 0) return [];
+      var startPage = Math.max(this.props.currPage - Math.floor(this.props.paginationSize / 2), this.props.pageStartIndex);
+      endPage = startPage + this.props.paginationSize - 1;
+
+      if (endPage > this.lastPage) {
+        endPage = this.lastPage;
+        startPage = endPage - this.props.paginationSize + 1;
+      }
+
+      if (startPage !== this.props.pageStartIndex && this.totalPages > this.props.paginationSize && this.props.withFirstAndLast) {
+        pages = [this.props.firstPage, this.props.prePage];
+      } else if (this.totalPages > 1 || this.props.alwaysShowAllBtns) {
+        pages = [this.props.prePage];
+      } else {
+        pages = [];
+      }
+
+      for (var i = startPage; i <= endPage; i++) {
+        if (i >= this.props.pageStartIndex) pages.push(i);
+      }
+
+      if (endPage <= this.lastPage && pages.length > 1) {
+        pages.push(this.props.nextPage);
+      }
+      if (endPage !== this.lastPage && this.props.withFirstAndLast) {
+        pages.push(this.props.lastPage);
+      }
+
+      return pages;
+    }
+  }]);
+
+  return PaginationList;
+}(_react.Component);
+
+PaginationList.propTypes = {
+  currPage: _propTypes2.default.number,
+  sizePerPage: _propTypes2.default.number,
+  dataSize: _propTypes2.default.number,
+  changePage: _propTypes2.default.func,
+  sizePerPageList: _propTypes2.default.array,
+  paginationShowsTotal: _propTypes2.default.oneOfType([_propTypes2.default.bool, _propTypes2.default.func]),
+  paginationSize: _propTypes2.default.number,
+  onSizePerPageList: _propTypes2.default.func,
+  prePage: _propTypes2.default.string,
+  pageStartIndex: _propTypes2.default.number,
+  hideSizePerPage: _propTypes2.default.bool,
+  alwaysShowAllBtns: _propTypes2.default.bool,
+  withFirstAndLast: _propTypes2.default.bool,
+  sizePerPageDropDown: _propTypes2.default.func,
+  paginationPanel: _propTypes2.default.func,
+  prePageTitle: _propTypes2.default.string,
+  nextPageTitle: _propTypes2.default.string,
+  firstPageTitle: _propTypes2.default.string,
+  lastPageTitle: _propTypes2.default.string,
+  hidePageListOnlyOnePage: _propTypes2.default.bool,
+  keepSizePerPageState: _propTypes2.default.bool
+};
+
+PaginationList.defaultProps = {
+  sizePerPage: _Const2.default.SIZE_PER_PAGE,
+  pageStartIndex: _Const2.default.PAGE_START_INDEX
+};
+
+var _default = PaginationList;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(PaginationList, 'PaginationList', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/pagination/PaginationList.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/pagination/PaginationList.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/pagination/SizePerPageDropDown.js

@@ -0,0 +1,120 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 sizePerPageDefaultClass = 'react-bs-table-sizePerPage-dropdown';
+
+var SizePerPageDropDown = function (_Component) {
+  _inherits(SizePerPageDropDown, _Component);
+
+  function SizePerPageDropDown() {
+    _classCallCheck(this, SizePerPageDropDown);
+
+    return _possibleConstructorReturn(this, (SizePerPageDropDown.__proto__ || Object.getPrototypeOf(SizePerPageDropDown)).apply(this, arguments));
+  }
+
+  _createClass(SizePerPageDropDown, [{
+    key: 'render',
+    value: function render() {
+      var _props = this.props,
+          open = _props.open,
+          hidden = _props.hidden,
+          onClick = _props.onClick,
+          onBlur = _props.onBlur,
+          options = _props.options,
+          className = _props.className,
+          variation = _props.variation,
+          btnContextual = _props.btnContextual,
+          currSizePerPage = _props.currSizePerPage;
+
+
+      var openClass = open ? 'open show' : '';
+      var dropDownStyle = { visibility: hidden ? 'hidden' : 'visible' };
+
+      return _react2.default.createElement(
+        'span',
+        { style: dropDownStyle,
+          className: variation + ' ' + openClass + ' ' + className + ' ' + sizePerPageDefaultClass },
+        _react2.default.createElement(
+          'button',
+          { className: 'btn ' + btnContextual + ' dropdown-toggle',
+            id: 'pageDropDown', 'data-toggle': 'dropdown',
+            'aria-expanded': open,
+            onClick: onClick,
+            onBlur: onBlur },
+          currSizePerPage,
+          _react2.default.createElement(
+            'span',
+            null,
+            ' ',
+            _react2.default.createElement('span', { className: 'caret' })
+          )
+        ),
+        _react2.default.createElement(
+          'ul',
+          { className: 'dropdown-menu', role: 'menu', 'aria-labelledby': 'pageDropDown' },
+          options
+        )
+      );
+    }
+  }]);
+
+  return SizePerPageDropDown;
+}(_react.Component);
+
+SizePerPageDropDown.propTypes = {
+  open: _propTypes2.default.bool,
+  hidden: _propTypes2.default.bool,
+  btnContextual: _propTypes2.default.string,
+  currSizePerPage: _propTypes2.default.string,
+  options: _propTypes2.default.array,
+  variation: _propTypes2.default.oneOf(['dropdown', 'dropup']),
+  className: _propTypes2.default.string,
+  onClick: _propTypes2.default.func,
+  onBlur: _propTypes2.default.func
+};
+SizePerPageDropDown.defaultProps = {
+  open: false,
+  hidden: false,
+  btnContextual: 'btn-default btn-secondary',
+  variation: 'dropdown',
+  className: ''
+};
+
+var _default = SizePerPageDropDown;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(sizePerPageDefaultClass, 'sizePerPageDefaultClass', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/pagination/SizePerPageDropDown.js');
+
+  __REACT_HOT_LOADER__.register(SizePerPageDropDown, 'SizePerPageDropDown', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/pagination/SizePerPageDropDown.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/pagination/SizePerPageDropDown.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/store/TableDataStore.js

@@ -0,0 +1,869 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TableDataStore = undefined;
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+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; }; }(); /* eslint no-nested-ternary: 0 */
+/* eslint guard-for-in: 0 */
+/* eslint no-console: 0 */
+/* eslint eqeqeq: 0 */
+/* eslint one-var: 0 */
+
+
+var _Const = require('../Const');
+
+var _Const2 = _interopRequireDefault(_Const);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var TableDataStore = function () {
+  function TableDataStore(data) {
+    var _this = this;
+
+    _classCallCheck(this, TableDataStore);
+
+    this.isValidKey = function () {
+      return _this.__isValidKey__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    this.data = data;
+    this.filteredData = null;
+    this.isOnFilter = false;
+    this.filterObj = null;
+    this.searchText = null;
+    this.sortList = [];
+    this.pageObj = {};
+    this.selected = [];
+    this.showOnlySelected = false;
+  }
+
+  _createClass(TableDataStore, [{
+    key: '__isValidKey__REACT_HOT_LOADER__',
+    value: function __isValidKey__REACT_HOT_LOADER__() {
+      return this.__isValidKey__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: 'setProps',
+    value: function setProps(props) {
+      this.keyField = props.keyField;
+      this.enablePagination = props.isPagination;
+      this.colInfos = props.colInfos;
+      this.remote = props.remote;
+      this.multiColumnSearch = props.multiColumnSearch;
+      // default behaviour if strictSearch prop is not provided: !multiColumnSearch
+      this.strictSearch = typeof props.strictSearch === 'undefined' ? !props.multiColumnSearch : props.strictSearch;
+      this.multiColumnSort = props.multiColumnSort;
+    }
+  }, {
+    key: 'clean',
+    value: function clean() {
+      this.filteredData = null;
+      this.isOnFilter = false;
+      this.filterObj = null;
+      this.searchText = null;
+      this.sortList = [];
+      this.pageObj = {};
+      this.selected = [];
+    }
+  }, {
+    key: 'isSearching',
+    value: function isSearching() {
+      return this.searchText !== null;
+    }
+  }, {
+    key: 'isFiltering',
+    value: function isFiltering() {
+      return this.filterObj !== null;
+    }
+  }, {
+    key: 'setData',
+    value: function setData(data) {
+      this.data = data;
+      if (this.remote) {
+        return;
+      }
+
+      this._refresh(true);
+    }
+  }, {
+    key: 'getColInfos',
+    value: function getColInfos() {
+      return this.colInfos;
+    }
+  }, {
+    key: 'getSortInfo',
+    value: function getSortInfo() {
+      return this.sortList;
+    }
+  }, {
+    key: 'setSortInfo',
+    value: function setSortInfo(order, sortField) {
+      if ((typeof order === 'undefined' ? 'undefined' : _typeof(order)) !== (typeof sortField === 'undefined' ? 'undefined' : _typeof(sortField))) {
+        throw new Error('The type of sort field and order should be both with String or Array');
+      }
+      if (Array.isArray(order) && Array.isArray(sortField)) {
+        if (order.length !== sortField.length) {
+          throw new Error('The length of sort fields and orders should be equivalent');
+        }
+        order = order.slice().reverse();
+        this.sortList = sortField.slice().reverse().map(function (field, i) {
+          return {
+            order: order[i],
+            sortField: field
+          };
+        });
+        this.sortList = this.sortList.slice(0, this.multiColumnSort);
+      } else {
+        var sortObj = {
+          order: order,
+          sortField: sortField
+        };
+
+        if (this.multiColumnSort > 1) {
+          var i = this.sortList.length - 1;
+          var sortFieldInHistory = false;
+
+          for (; i >= 0; i--) {
+            if (this.sortList[i].sortField === sortField) {
+              sortFieldInHistory = true;
+              break;
+            }
+          }
+
+          if (sortFieldInHistory) {
+            if (i > 0) {
+              this.sortList = this.sortList.slice(0, i);
+            } else {
+              this.sortList = this.sortList.slice(1);
+            }
+          }
+
+          this.sortList.unshift(sortObj);
+          this.sortList = this.sortList.slice(0, this.multiColumnSort);
+        } else {
+          this.sortList = [sortObj];
+        }
+      }
+    }
+  }, {
+    key: 'cleanSortInfo',
+    value: function cleanSortInfo() {
+      this.sortList = [];
+    }
+  }, {
+    key: 'setSelectedRowKey',
+    value: function setSelectedRowKey(selectedRowKeys) {
+      this.selected = selectedRowKeys;
+    }
+  }, {
+    key: 'getRowByKey',
+    value: function getRowByKey(keys) {
+      var _this2 = this;
+
+      // Bad Performance #1164
+      // return keys.map(key => {
+      //   const result = this.data.filter(d => d[this.keyField] === key);
+      //   if (result.length !== 0) return result[0];
+      // });
+      var result = [];
+      if (!keys || keys.length === 0) {
+        return result;
+      }
+
+      var _loop = function _loop(i) {
+        var d = _this2.data[i];
+        if (keys.indexOf(d[_this2.keyField]) > -1) {
+          keys = keys.filter(function (k) {
+            return k !== d[_this2.keyField];
+          });
+          result.push(d);
+        }
+      };
+
+      for (var i = 0; i < this.data.length; i++) {
+        _loop(i);
+      }
+      return result;
+    }
+  }, {
+    key: 'getSelectedRowKeys',
+    value: function getSelectedRowKeys() {
+      return this.selected;
+    }
+  }, {
+    key: 'getCurrentDisplayData',
+    value: function getCurrentDisplayData() {
+      if (this.isOnFilter) return this.filteredData;else return this.data;
+    }
+  }, {
+    key: '_refresh',
+    value: function _refresh(skipSorting) {
+      if (this.isOnFilter) {
+        if (this.filterObj !== null) this.filter(this.filterObj);
+        if (this.searchText !== null) this.search(this.searchText);
+      }
+      if (!skipSorting && this.sortList.length > 0) {
+        this.sort();
+      }
+    }
+  }, {
+    key: 'ignoreNonSelected',
+    value: function ignoreNonSelected() {
+      var _this3 = this;
+
+      this.showOnlySelected = !this.showOnlySelected;
+      if (this.showOnlySelected) {
+        this.isOnFilter = true;
+        this.filteredData = this.data.filter(function (row) {
+          var result = _this3.selected.find(function (x) {
+            return row[_this3.keyField] === x;
+          });
+          return typeof result !== 'undefined' ? true : false;
+        });
+      } else {
+        this.isOnFilter = false;
+      }
+    }
+  }, {
+    key: 'sort',
+    value: function sort() {
+      var currentDisplayData = this.getCurrentDisplayData();
+
+      currentDisplayData = this._sort(currentDisplayData);
+
+      return this;
+    }
+  }, {
+    key: 'page',
+    value: function page(_page, sizePerPage) {
+      this.pageObj.end = _page * sizePerPage - 1;
+      this.pageObj.start = this.pageObj.end - (sizePerPage - 1);
+      return this;
+    }
+  }, {
+    key: 'edit',
+    value: function edit(newVal, rowIndex, fieldName) {
+      var currentDisplayData = this.getCurrentDisplayData();
+      var rowKeyCache = void 0;
+      if (!this.enablePagination) {
+        currentDisplayData[rowIndex][fieldName] = newVal;
+        rowKeyCache = currentDisplayData[rowIndex][this.keyField];
+      } else {
+        currentDisplayData[this.pageObj.start + rowIndex][fieldName] = newVal;
+        rowKeyCache = currentDisplayData[this.pageObj.start + rowIndex][this.keyField];
+      }
+      if (this.isOnFilter) {
+        this.data.forEach(function (row) {
+          if (row[this.keyField] === rowKeyCache) {
+            row[fieldName] = newVal;
+          }
+        }, this);
+        if (this.filterObj !== null) this.filter(this.filterObj);
+        if (this.searchText !== null) this.search(this.searchText);
+      }
+      return this;
+    }
+  }, {
+    key: 'addAtBegin',
+    value: function addAtBegin(newObj) {
+      if (!newObj[this.keyField] || newObj[this.keyField].toString() === '') {
+        throw new Error(this.keyField + ' can\'t be empty value.');
+      }
+      var currentDisplayData = this.getCurrentDisplayData();
+      currentDisplayData.forEach(function (row) {
+        if (row[this.keyField].toString() === newObj[this.keyField].toString()) {
+          throw new Error(this.keyField + ' ' + newObj[this.keyField] + ' already exists');
+        }
+      }, this);
+      currentDisplayData.unshift(newObj);
+      if (this.isOnFilter) {
+        this.data.unshift(newObj);
+      }
+      this._refresh(false);
+    }
+  }, {
+    key: 'add',
+    value: function add(newObj) {
+      var e = this.isValidKey(newObj[this.keyField]);
+      if (e) throw new Error(e);
+
+      var currentDisplayData = this.getCurrentDisplayData();
+      currentDisplayData.push(newObj);
+      if (this.isOnFilter) {
+        this.data.push(newObj);
+      }
+      this._refresh(false);
+    }
+  }, {
+    key: '__isValidKey__REACT_HOT_LOADER__',
+    value: function __isValidKey__REACT_HOT_LOADER__(key) {
+      var _this4 = this;
+
+      if (key === null || key === undefined || key.toString() === '') {
+        return this.keyField + ' can\'t be empty value.';
+      }
+      var currentDisplayData = this.getCurrentDisplayData();
+      var exist = currentDisplayData.find(function (row) {
+        return row[_this4.keyField].toString() === key.toString();
+      });
+      if (exist) return this.keyField + ' ' + key + ' already exists';
+    }
+  }, {
+    key: 'remove',
+    value: function remove(rowKey) {
+      var _this5 = this;
+
+      var currentDisplayData = this.getCurrentDisplayData();
+      var result = currentDisplayData.filter(function (row) {
+        return rowKey.indexOf(row[_this5.keyField]) === -1;
+      });
+
+      if (this.isOnFilter) {
+        this.data = this.data.filter(function (row) {
+          return rowKey.indexOf(row[_this5.keyField]) === -1;
+        });
+        this.filteredData = result;
+      } else {
+        this.data = result;
+      }
+    }
+  }, {
+    key: 'filter',
+    value: function filter(filterObj) {
+      if (Object.keys(filterObj).length === 0) {
+        this.filteredData = null;
+        this.isOnFilter = false;
+        this.filterObj = null;
+        if (this.searchText) this._search(this.data);
+      } else {
+        var source = this.data;
+        this.filterObj = filterObj;
+        if (this.searchText) {
+          this._search(source);
+          source = this.filteredData;
+        }
+        this._filter(source);
+      }
+    }
+  }, {
+    key: 'filterNumber',
+    value: function filterNumber(targetVal, filterVal, comparator) {
+      var valid = true;
+      switch (comparator) {
+        case '=':
+          {
+            if (targetVal != filterVal) {
+              valid = false;
+            }
+            break;
+          }
+        case '>':
+          {
+            if (targetVal <= filterVal) {
+              valid = false;
+            }
+            break;
+          }
+        case '>=':
+          {
+            if (targetVal < filterVal) {
+              valid = false;
+            }
+            break;
+          }
+        case '<':
+          {
+            if (targetVal >= filterVal) {
+              valid = false;
+            }
+            break;
+          }
+        case '<=':
+          {
+            if (targetVal > filterVal) {
+              valid = false;
+            }
+            break;
+          }
+        case '!=':
+          {
+            if (targetVal == filterVal) {
+              valid = false;
+            }
+            break;
+          }
+        default:
+          {
+            console.error('Number comparator provided is not supported');
+            break;
+          }
+      }
+      return valid;
+    }
+  }, {
+    key: 'filterDate',
+    value: function filterDate(targetVal, filterVal, comparator) {
+      if (!targetVal) return false;
+
+      var filterDate = filterVal.getDate();
+      var filterMonth = filterVal.getMonth();
+      var filterYear = filterVal.getFullYear();
+
+      if ((typeof targetVal === 'undefined' ? 'undefined' : _typeof(targetVal)) !== 'object') {
+        targetVal = new Date(targetVal);
+      }
+
+      var targetDate = targetVal.getDate();
+      var targetMonth = targetVal.getMonth();
+      var targetYear = targetVal.getFullYear();
+
+      var valid = true;
+      switch (comparator) {
+        case '=':
+          {
+            if (filterDate !== targetDate || filterMonth !== targetMonth || filterYear !== targetYear) {
+              valid = false;
+            }
+            break;
+          }
+        case '>':
+          {
+            if (targetVal <= filterVal) {
+              valid = false;
+            }
+            break;
+          }
+        case '>=':
+          {
+            if (targetYear < filterYear) {
+              valid = false;
+            } else if (targetYear === filterYear && targetMonth < filterMonth) {
+              valid = false;
+            } else if (targetYear === filterYear && targetMonth === filterMonth && targetDate < filterDate) {
+              valid = false;
+            }
+            break;
+          }
+        case '<':
+          {
+            if (targetVal >= filterVal) {
+              valid = false;
+            }
+            break;
+          }
+        case '<=':
+          {
+            if (targetYear > filterYear) {
+              valid = false;
+            } else if (targetYear === filterYear && targetMonth > filterMonth) {
+              valid = false;
+            } else if (targetYear === filterYear && targetMonth === filterMonth && targetDate > filterDate) {
+              valid = false;
+            }
+            break;
+          }
+        case '!=':
+          {
+            if (filterDate === targetDate && filterMonth === targetMonth && filterYear === targetYear) {
+              valid = false;
+            }
+            break;
+          }
+        default:
+          {
+            console.error('Date comparator provided is not supported');
+            break;
+          }
+      }
+      return valid;
+    }
+  }, {
+    key: 'filterRegex',
+    value: function filterRegex(targetVal, filterVal) {
+      try {
+        return new RegExp(filterVal, 'i').test(targetVal);
+      } catch (e) {
+        return true;
+      }
+    }
+  }, {
+    key: 'filterCustom',
+    value: function filterCustom(targetVal, filterVal, callbackInfo, cond) {
+      if (callbackInfo !== null && (typeof callbackInfo === 'undefined' ? 'undefined' : _typeof(callbackInfo)) === 'object') {
+        return callbackInfo.callback(targetVal, callbackInfo.callbackParameters);
+      }
+
+      return this.filterText(targetVal, filterVal, cond);
+    }
+  }, {
+    key: 'filterText',
+    value: function filterText(targetVal, filterVal) {
+      var cond = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _Const2.default.FILTER_COND_LIKE;
+
+      targetVal = targetVal.toString();
+      filterVal = filterVal.toString();
+      if (cond === _Const2.default.FILTER_COND_EQ) {
+        return targetVal === filterVal;
+      } else {
+        targetVal = targetVal.toLowerCase();
+        filterVal = filterVal.toLowerCase();
+        return !(targetVal.indexOf(filterVal) === -1);
+      }
+    }
+
+    /**
+     * Filter if targetVal is contained in filterVal.
+     */
+
+  }, {
+    key: 'filterArray',
+    value: function filterArray(targetVal, filterVal) {
+      // case insensitive
+      return filterVal.indexOf(targetVal) > -1;
+    }
+
+    /* General search function
+     * It will search for the text if the input includes that text;
+     */
+
+  }, {
+    key: 'search',
+    value: function search(searchText) {
+      if (searchText.trim() === '') {
+        this.filteredData = null;
+        this.isOnFilter = false;
+        this.searchText = null;
+        if (this.filterObj) this._filter(this.data);
+      } else {
+        var source = this.data;
+        this.searchText = searchText;
+        if (this.filterObj) {
+          this._filter(source);
+          source = this.filteredData;
+        }
+        this._search(source);
+      }
+    }
+  }, {
+    key: '_filter',
+    value: function _filter(source) {
+      var _this6 = this;
+
+      var filterObj = this.filterObj;
+      this.filteredData = source.filter(function (row, r) {
+        var valid = true;
+        var filterVal = void 0;
+        for (var key in filterObj) {
+          var targetVal = row[key];
+          if (targetVal === null || targetVal === undefined) {
+            targetVal = '';
+          }
+
+          switch (filterObj[key].type) {
+            case _Const2.default.FILTER_TYPE.NUMBER:
+              {
+                filterVal = filterObj[key].value.number;
+                break;
+              }
+            case _Const2.default.FILTER_TYPE.CUSTOM:
+              {
+                filterVal = _typeof(filterObj[key].value) === 'object' ? undefined : typeof filterObj[key].value === 'string' ? filterObj[key].value.toLowerCase() : filterObj[key].value;
+                break;
+              }
+            case _Const2.default.FILTER_TYPE.DATE:
+              {
+                filterVal = filterObj[key].value.date;
+                break;
+              }
+            case _Const2.default.FILTER_TYPE.REGEX:
+              {
+                filterVal = filterObj[key].value;
+                break;
+              }
+            case _Const2.default.FILTER_TYPE.ARRAY:
+              {
+                filterVal = filterObj[key].value;
+                if (!Array.isArray(filterVal)) {
+                  throw new Error('Value must be an Array');
+                }
+                break;
+              }
+            default:
+              {
+                filterVal = filterObj[key].value;
+                if (filterVal === undefined) {
+                  // Support old filter
+                  filterVal = filterObj[key];
+                }
+                break;
+              }
+          }
+          var format = void 0,
+              filterFormatted = void 0,
+              formatExtraData = void 0,
+              filterValue = void 0;
+          if (_this6.colInfos[key]) {
+            format = _this6.colInfos[key].format;
+            filterFormatted = _this6.colInfos[key].filterFormatted;
+            formatExtraData = _this6.colInfos[key].formatExtraData;
+            filterValue = _this6.colInfos[key].filterValue;
+            if (filterFormatted && format) {
+              targetVal = format(row[key], row, formatExtraData, r);
+            } else if (filterValue) {
+              targetVal = filterValue(row[key], row);
+            }
+          }
+
+          switch (filterObj[key].type) {
+            case _Const2.default.FILTER_TYPE.NUMBER:
+              {
+                valid = _this6.filterNumber(targetVal, filterVal, filterObj[key].value.comparator);
+                break;
+              }
+            case _Const2.default.FILTER_TYPE.DATE:
+              {
+                valid = _this6.filterDate(targetVal, filterVal, filterObj[key].value.comparator);
+                break;
+              }
+            case _Const2.default.FILTER_TYPE.REGEX:
+              {
+                valid = _this6.filterRegex(targetVal, filterVal);
+                break;
+              }
+            case _Const2.default.FILTER_TYPE.CUSTOM:
+              {
+                var cond = filterObj[key].props ? filterObj[key].props.cond : _Const2.default.FILTER_COND_LIKE;
+                valid = _this6.filterCustom(targetVal, filterVal, filterObj[key].value, cond);
+                break;
+              }
+            case _Const2.default.FILTER_TYPE.ARRAY:
+              {
+                valid = _this6.filterArray(targetVal, filterVal);
+                break;
+              }
+            default:
+              {
+                if (filterObj[key].type === _Const2.default.FILTER_TYPE.SELECT && filterFormatted && filterFormatted && format) {
+                  filterVal = format(filterVal, row, formatExtraData, r);
+                }
+                var _cond = filterObj[key].props ? filterObj[key].props.cond : _Const2.default.FILTER_COND_LIKE;
+                valid = _this6.filterText(targetVal, filterVal, _cond);
+                break;
+              }
+          }
+          if (!valid) {
+            break;
+          }
+        }
+        return valid;
+      });
+      this.isOnFilter = true;
+    }
+
+    /*
+     * Four different sort modes, all case insensitive:
+     * (1) strictSearch && !multiColumnSearch
+     *     search text must be contained as provided in a single column
+     * (2) strictSearch && multiColumnSearch
+     *     conjunction (AND combination) of whitespace separated terms over multiple columns
+     * (3) !strictSearch && !multiColumnSearch
+     *     conjunction (AND combination) of whitespace separated terms in a single column
+     * (4) !strictSearch && multiColumnSearch
+     *     any of the whitespace separated terms must be contained in any column
+     */
+
+  }, {
+    key: '_search',
+    value: function _search(source) {
+      var _this7 = this;
+
+      var searchTextArray = void 0;
+      if (this.multiColumnSearch || !this.strictSearch) {
+        // ignore leading and trailing whitespaces
+        searchTextArray = this.searchText.trim().toLowerCase().split(/\s+/);
+      } else {
+        searchTextArray = [this.searchText.toLowerCase()];
+      }
+      var searchTermCount = searchTextArray.length;
+      var multipleTerms = searchTermCount > 1;
+      var nonStrictMultiCol = multipleTerms && !this.strictSearch && this.multiColumnSearch;
+      var nonStrictSingleCol = multipleTerms && !this.strictSearch && !this.multiColumnSearch;
+      this.filteredData = source.filter(function (row, r) {
+        var keys = Object.keys(row);
+        // only clone array if necessary
+        var searchTerms = multipleTerms ? searchTextArray.slice() : searchTextArray;
+        // for loops are ugly, but performance matters here.
+        // And you cant break from a forEach.
+        // http://jsperf.com/for-vs-foreach/66
+        for (var i = 0, keysLength = keys.length; i < keysLength; i++) {
+          var key = keys[i];
+          var colInfo = _this7.colInfos[key];
+          if (colInfo && colInfo.searchable) {
+            var format = colInfo.format,
+                filterFormatted = colInfo.filterFormatted,
+                filterValue = colInfo.filterValue,
+                formatExtraData = colInfo.formatExtraData;
+
+            var targetVal = void 0;
+            if (filterFormatted && format) {
+              targetVal = format(row[key], row, formatExtraData, r);
+            } else if (filterValue) {
+              targetVal = filterValue(row[key], row);
+            } else {
+              targetVal = row[key];
+            }
+            if (targetVal !== null && typeof targetVal !== 'undefined') {
+              targetVal = targetVal.toString().toLowerCase();
+              if (nonStrictSingleCol && searchTermCount > searchTerms.length) {
+                // reset search terms for single column search
+                searchTerms = searchTextArray.slice();
+              }
+              for (var j = searchTerms.length - 1; j > -1; j--) {
+                if (targetVal.indexOf(searchTerms[j]) !== -1) {
+                  if (nonStrictMultiCol || searchTerms.length === 1) {
+                    // match found: the last or only one
+                    return true;
+                  }
+                  // match found: but there are more search terms to check for
+                  searchTerms.splice(j, 1);
+                } else if (!_this7.multiColumnSearch) {
+                  // one of the search terms was not found in this column
+                  break;
+                }
+              }
+            }
+          }
+        }
+        return false;
+      });
+      this.isOnFilter = true;
+    }
+  }, {
+    key: '_sort',
+    value: function _sort(arr) {
+      var _this8 = this;
+
+      if (this.sortList.length === 0 || typeof this.sortList[0] === 'undefined') {
+        return arr;
+      }
+
+      arr.sort(function (a, b) {
+        var result = 0;
+
+        for (var i = 0; i < _this8.sortList.length; i++) {
+          var sortDetails = _this8.sortList[i];
+          var isDesc = sortDetails.order.toLowerCase() === _Const2.default.SORT_DESC;
+
+          var _colInfos$sortDetails = _this8.colInfos[sortDetails.sortField],
+              sortFunc = _colInfos$sortDetails.sortFunc,
+              sortFuncExtraData = _colInfos$sortDetails.sortFuncExtraData;
+
+
+          if (sortFunc) {
+            result = sortFunc(a, b, sortDetails.order, sortDetails.sortField, sortFuncExtraData);
+          } else {
+            var valueA = a[sortDetails.sortField] == null ? '' : a[sortDetails.sortField];
+            var valueB = b[sortDetails.sortField] == null ? '' : b[sortDetails.sortField];
+
+            if (isDesc) {
+              if (typeof valueB === 'string') {
+                result = valueB.localeCompare(valueA);
+              } else {
+                result = valueA > valueB ? -1 : valueA < valueB ? 1 : 0;
+              }
+            } else {
+              if (typeof valueA === 'string') {
+                result = valueA.localeCompare(valueB);
+              } else {
+                result = valueA < valueB ? -1 : valueA > valueB ? 1 : 0;
+              }
+            }
+          }
+
+          if (result !== 0) {
+            return result;
+          }
+        }
+
+        return result;
+      });
+
+      return arr;
+    }
+  }, {
+    key: 'getDataIgnoringPagination',
+    value: function getDataIgnoringPagination() {
+      return this.getCurrentDisplayData();
+    }
+  }, {
+    key: 'get',
+    value: function get() {
+      var _data = this.getCurrentDisplayData();
+
+      if (_data.length === 0) return _data;
+
+      var remote = typeof this.remote === 'function' ? this.remote(_Const2.default.REMOTE)[_Const2.default.REMOTE_PAGE] : this.remote;
+
+      if (remote || !this.enablePagination) {
+        return _data;
+      } else {
+        var result = [];
+        for (var i = this.pageObj.start; i <= this.pageObj.end; i++) {
+          result.push(_data[i]);
+          if (i + 1 === _data.length) break;
+        }
+        return result;
+      }
+    }
+  }, {
+    key: 'getKeyField',
+    value: function getKeyField() {
+      return this.keyField;
+    }
+  }, {
+    key: 'getDataNum',
+    value: function getDataNum() {
+      return this.getCurrentDisplayData().length;
+    }
+  }, {
+    key: 'isChangedPage',
+    value: function isChangedPage() {
+      return this.pageObj.start && this.pageObj.end ? true : false;
+    }
+  }, {
+    key: 'isEmpty',
+    value: function isEmpty() {
+      return this.data.length === 0 || this.data === null || this.data === undefined;
+    }
+  }, {
+    key: 'getAllRowkey',
+    value: function getAllRowkey() {
+      var _this9 = this;
+
+      return this.data.map(function (row) {
+        return row[_this9.keyField];
+      });
+    }
+  }]);
+
+  return TableDataStore;
+}();
+
+exports.TableDataStore = TableDataStore;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(TableDataStore, 'TableDataStore', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/store/TableDataStore.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/toolbar/ButtonGroup.js

@@ -0,0 +1,81 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+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 ButtonGroup = function (_Component) {
+  _inherits(ButtonGroup, _Component);
+
+  function ButtonGroup() {
+    _classCallCheck(this, ButtonGroup);
+
+    return _possibleConstructorReturn(this, (ButtonGroup.__proto__ || Object.getPrototypeOf(ButtonGroup)).apply(this, arguments));
+  }
+
+  _createClass(ButtonGroup, [{
+    key: 'render',
+    value: function render() {
+      var _props = this.props,
+          className = _props.className,
+          sizeClass = _props.sizeClass,
+          children = _props.children,
+          rest = _objectWithoutProperties(_props, ['className', 'sizeClass', 'children']);
+
+      return _react2.default.createElement(
+        'div',
+        _extends({ className: 'btn-group ' + sizeClass + ' ' + className, role: 'group' }, rest),
+        children
+      );
+    }
+  }]);
+
+  return ButtonGroup;
+}(_react.Component);
+
+ButtonGroup.propTypes = {
+  sizeClass: _propTypes2.default.string,
+  className: _propTypes2.default.string
+};
+ButtonGroup.defaultProps = {
+  sizeClass: 'btn-group-sm',
+  className: ''
+};
+
+var _default = ButtonGroup;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(ButtonGroup, 'ButtonGroup', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/ButtonGroup.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/ButtonGroup.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/toolbar/ClearSearchButton.js

@@ -0,0 +1,100 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+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 clearBtnDefaultClass = 'react-bs-table-search-clear-btn';
+
+var ClearSearchButton = function (_Component) {
+  _inherits(ClearSearchButton, _Component);
+
+  function ClearSearchButton() {
+    _classCallCheck(this, ClearSearchButton);
+
+    return _possibleConstructorReturn(this, (ClearSearchButton.__proto__ || Object.getPrototypeOf(ClearSearchButton)).apply(this, arguments));
+  }
+
+  _createClass(ClearSearchButton, [{
+    key: 'render',
+    value: function render() {
+      var _props = this.props,
+          btnContextual = _props.btnContextual,
+          className = _props.className,
+          onClick = _props.onClick,
+          btnText = _props.btnText,
+          children = _props.children,
+          rest = _objectWithoutProperties(_props, ['btnContextual', 'className', 'onClick', 'btnText', 'children']);
+
+      var content = children || _react2.default.createElement(
+        'span',
+        null,
+        btnText
+      );
+      return _react2.default.createElement(
+        'button',
+        _extends({ ref: 'btn',
+          className: 'btn ' + btnContextual + ' ' + className + ' ' + clearBtnDefaultClass,
+          type: 'button',
+          onClick: onClick
+        }, rest),
+        content
+      );
+    }
+  }]);
+
+  return ClearSearchButton;
+}(_react.Component);
+
+ClearSearchButton.propTypes = {
+  btnContextual: _propTypes2.default.string,
+  className: _propTypes2.default.string,
+  btnText: _propTypes2.default.string,
+  onClick: _propTypes2.default.func
+};
+ClearSearchButton.defaultProps = {
+  btnContextual: 'btn-default btn-secondary',
+  className: '',
+  btnText: 'Clear',
+  onClick: undefined
+};
+
+var _default = ClearSearchButton;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(clearBtnDefaultClass, 'clearBtnDefaultClass', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/ClearSearchButton.js');
+
+  __REACT_HOT_LOADER__.register(ClearSearchButton, 'ClearSearchButton', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/ClearSearchButton.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/ClearSearchButton.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/toolbar/DeleteButton.js

@@ -0,0 +1,108 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _Const = require('../Const');
+
+var _Const2 = _interopRequireDefault(_Const);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+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 deleteBtnDefaultClass = 'react-bs-table-del-btn';
+
+var DeleteButton = function (_Component) {
+  _inherits(DeleteButton, _Component);
+
+  function DeleteButton() {
+    _classCallCheck(this, DeleteButton);
+
+    return _possibleConstructorReturn(this, (DeleteButton.__proto__ || Object.getPrototypeOf(DeleteButton)).apply(this, arguments));
+  }
+
+  _createClass(DeleteButton, [{
+    key: 'render',
+    value: function render() {
+      var _props = this.props,
+          btnContextual = _props.btnContextual,
+          className = _props.className,
+          onClick = _props.onClick,
+          btnGlyphicon = _props.btnGlyphicon,
+          btnText = _props.btnText,
+          children = _props.children,
+          rest = _objectWithoutProperties(_props, ['btnContextual', 'className', 'onClick', 'btnGlyphicon', 'btnText', 'children']);
+
+      var content = children || _react2.default.createElement(
+        'span',
+        null,
+        _react2.default.createElement('i', { className: 'fa glyphicon ' + btnGlyphicon }),
+        ' ',
+        btnText
+      );
+      return _react2.default.createElement(
+        'button',
+        _extends({ type: 'button',
+          className: 'btn ' + btnContextual + ' ' + deleteBtnDefaultClass + ' ' + className,
+          onClick: onClick
+        }, rest),
+        content
+      );
+    }
+  }]);
+
+  return DeleteButton;
+}(_react.Component);
+
+DeleteButton.propTypes = {
+  btnText: _propTypes2.default.string,
+  btnContextual: _propTypes2.default.string,
+  className: _propTypes2.default.string,
+  onClick: _propTypes2.default.func,
+  btnGlyphicon: _propTypes2.default.string
+};
+DeleteButton.defaultProps = {
+  btnText: _Const2.default.DELETE_BTN_TEXT,
+  btnContextual: 'btn-warning',
+  className: '',
+  onClick: undefined,
+  btnGlyphicon: 'glyphicon-trash fa-trash'
+};
+
+var _default = DeleteButton;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(deleteBtnDefaultClass, 'deleteBtnDefaultClass', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/DeleteButton.js');
+
+  __REACT_HOT_LOADER__.register(DeleteButton, 'DeleteButton', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/DeleteButton.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/DeleteButton.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/toolbar/ExportCSVButton.js

@@ -0,0 +1,108 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _Const = require('../Const');
+
+var _Const2 = _interopRequireDefault(_Const);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+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 exportCsvBtnDefaultClass = 'react-bs-table-csv-btn';
+
+var ExportCSVButton = function (_Component) {
+  _inherits(ExportCSVButton, _Component);
+
+  function ExportCSVButton() {
+    _classCallCheck(this, ExportCSVButton);
+
+    return _possibleConstructorReturn(this, (ExportCSVButton.__proto__ || Object.getPrototypeOf(ExportCSVButton)).apply(this, arguments));
+  }
+
+  _createClass(ExportCSVButton, [{
+    key: 'render',
+    value: function render() {
+      var _props = this.props,
+          btnContextual = _props.btnContextual,
+          className = _props.className,
+          onClick = _props.onClick,
+          btnGlyphicon = _props.btnGlyphicon,
+          btnText = _props.btnText,
+          children = _props.children,
+          rest = _objectWithoutProperties(_props, ['btnContextual', 'className', 'onClick', 'btnGlyphicon', 'btnText', 'children']);
+
+      var content = children || _react2.default.createElement(
+        'span',
+        null,
+        _react2.default.createElement('i', { className: 'fa glyphicon ' + btnGlyphicon }),
+        ' ',
+        btnText
+      );
+      return _react2.default.createElement(
+        'button',
+        _extends({ type: 'button',
+          className: 'btn ' + btnContextual + ' ' + exportCsvBtnDefaultClass + ' ' + className + ' hidden-print',
+          onClick: onClick
+        }, rest),
+        content
+      );
+    }
+  }]);
+
+  return ExportCSVButton;
+}(_react.Component);
+
+ExportCSVButton.propTypes = {
+  btnText: _propTypes2.default.string,
+  btnContextual: _propTypes2.default.string,
+  className: _propTypes2.default.string,
+  onClick: _propTypes2.default.func,
+  btnGlyphicon: _propTypes2.default.string
+};
+ExportCSVButton.defaultProps = {
+  btnText: _Const2.default.EXPORT_CSV_TEXT,
+  btnContextual: 'btn-success',
+  className: '',
+  onClick: undefined,
+  btnGlyphicon: 'glyphicon-export fa-download'
+};
+
+var _default = ExportCSVButton;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(exportCsvBtnDefaultClass, 'exportCsvBtnDefaultClass', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/ExportCSVButton.js');
+
+  __REACT_HOT_LOADER__.register(ExportCSVButton, 'ExportCSVButton', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/ExportCSVButton.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/ExportCSVButton.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/toolbar/InsertButton.js

@@ -0,0 +1,108 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _Const = require('../Const');
+
+var _Const2 = _interopRequireDefault(_Const);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+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 insertBtnDefaultClass = 'react-bs-table-add-btn';
+
+var InsertButton = function (_Component) {
+  _inherits(InsertButton, _Component);
+
+  function InsertButton() {
+    _classCallCheck(this, InsertButton);
+
+    return _possibleConstructorReturn(this, (InsertButton.__proto__ || Object.getPrototypeOf(InsertButton)).apply(this, arguments));
+  }
+
+  _createClass(InsertButton, [{
+    key: 'render',
+    value: function render() {
+      var _props = this.props,
+          btnContextual = _props.btnContextual,
+          className = _props.className,
+          onClick = _props.onClick,
+          btnGlyphicon = _props.btnGlyphicon,
+          btnText = _props.btnText,
+          children = _props.children,
+          rest = _objectWithoutProperties(_props, ['btnContextual', 'className', 'onClick', 'btnGlyphicon', 'btnText', 'children']);
+
+      var content = children || _react2.default.createElement(
+        'span',
+        null,
+        _react2.default.createElement('i', { className: 'fa glyphicon ' + btnGlyphicon }),
+        ' ',
+        btnText
+      );
+      return _react2.default.createElement(
+        'button',
+        _extends({ type: 'button',
+          className: 'btn ' + btnContextual + ' ' + insertBtnDefaultClass + ' ' + className,
+          onClick: onClick
+        }, rest),
+        content
+      );
+    }
+  }]);
+
+  return InsertButton;
+}(_react.Component);
+
+InsertButton.propTypes = {
+  btnText: _propTypes2.default.string,
+  btnContextual: _propTypes2.default.string,
+  className: _propTypes2.default.string,
+  onClick: _propTypes2.default.func,
+  btnGlyphicon: _propTypes2.default.string
+};
+InsertButton.defaultProps = {
+  btnText: _Const2.default.INSERT_BTN_TEXT,
+  btnContextual: 'btn-info',
+  className: '',
+  onClick: undefined,
+  btnGlyphicon: 'glyphicon-plus fa-plus'
+};
+
+var _default = InsertButton;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(insertBtnDefaultClass, 'insertBtnDefaultClass', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/InsertButton.js');
+
+  __REACT_HOT_LOADER__.register(InsertButton, 'InsertButton', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/InsertButton.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/InsertButton.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/toolbar/InsertModal.js

@@ -0,0 +1,189 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _InsertModalHeader = require('./InsertModalHeader');
+
+var _InsertModalHeader2 = _interopRequireDefault(_InsertModalHeader);
+
+var _InsertModalFooter = require('./InsertModalFooter');
+
+var _InsertModalFooter2 = _interopRequireDefault(_InsertModalFooter);
+
+var _InsertModalBody = require('./InsertModalBody');
+
+var _InsertModalBody2 = _interopRequireDefault(_InsertModalBody);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; } /* eslint no-console: 0 */
+
+var defaultModalClassName = 'react-bs-table-insert-modal';
+
+var InsertModal = function (_Component) {
+  _inherits(InsertModal, _Component);
+
+  function InsertModal() {
+    var _ref;
+
+    var _temp, _this, _ret;
+
+    _classCallCheck(this, InsertModal);
+
+    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = InsertModal.__proto__ || Object.getPrototypeOf(InsertModal)).call.apply(_ref, [this].concat(args))), _this), _this.handleSave = function () {
+      var _this2;
+
+      return (_this2 = _this).__handleSave__REACT_HOT_LOADER__.apply(_this2, arguments);
+    }, _temp), _possibleConstructorReturn(_this, _ret);
+  }
+
+  _createClass(InsertModal, [{
+    key: '__handleSave__REACT_HOT_LOADER__',
+    value: function __handleSave__REACT_HOT_LOADER__() {
+      return this.__handleSave__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__handleSave__REACT_HOT_LOADER__',
+    value: function __handleSave__REACT_HOT_LOADER__() {
+      var bodyRefs = this.refs.body;
+      if (bodyRefs.getFieldValue) {
+        this.props.onSave(bodyRefs.getFieldValue());
+      } else {
+        console.error('Custom InsertModalBody should implement getFieldValue function\n        and should return an object presented as the new row that user input.');
+      }
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      var _props = this.props,
+          headerComponent = _props.headerComponent,
+          footerComponent = _props.footerComponent,
+          bodyComponent = _props.bodyComponent;
+      var _props2 = this.props,
+          columns = _props2.columns,
+          validateState = _props2.validateState,
+          ignoreEditable = _props2.ignoreEditable,
+          onModalClose = _props2.onModalClose;
+
+      var bodyAttr = { columns: columns, validateState: validateState, ignoreEditable: ignoreEditable };
+
+      bodyComponent = bodyComponent && bodyComponent(columns, validateState, ignoreEditable);
+
+      headerComponent = headerComponent && headerComponent(onModalClose, this.handleSave);
+
+      footerComponent = footerComponent && footerComponent(onModalClose, this.handleSave);
+
+      if (bodyComponent) {
+        bodyComponent = _react2.default.cloneElement(bodyComponent, { ref: 'body' });
+      }
+
+      if (headerComponent && headerComponent.type.name === _InsertModalHeader2.default.name) {
+        var eventProps = {};
+        if (!headerComponent.props.onModalClose) eventProps.onModalClose = onModalClose;
+        if (!headerComponent.props.onSave) eventProps.onSave = this.handleSave;
+        if (Object.keys(eventProps).length > 0) {
+          headerComponent = _react2.default.cloneElement(headerComponent, eventProps);
+        }
+      } else if (headerComponent && headerComponent.type.name !== _InsertModalHeader2.default.name) {
+        var className = headerComponent.props.className;
+
+        if (typeof className === 'undefined' || className.indexOf('modal-header') === -1) {
+          headerComponent = _react2.default.createElement(
+            'div',
+            { className: 'modal-header' },
+            headerComponent
+          );
+        }
+      }
+
+      if (footerComponent && footerComponent.type.name === _InsertModalFooter2.default.name) {
+        var _eventProps = {};
+        if (!footerComponent.props.onModalClose) _eventProps.onModalClose = onModalClose;
+        if (!footerComponent.props.onSave) _eventProps.onSave = this.handleSave;
+        if (Object.keys(_eventProps).length > 0) {
+          footerComponent = _react2.default.cloneElement(footerComponent, _eventProps);
+        }
+      } else if (footerComponent && footerComponent.type.name !== _InsertModalFooter2.default.name) {
+        var _className = footerComponent.props.className;
+
+        if (typeof _className === 'undefined' || _className.indexOf('modal-footer') === -1) {
+          footerComponent = _react2.default.createElement(
+            'div',
+            { className: 'modal-footer' },
+            footerComponent
+          );
+        }
+      }
+
+      return _react2.default.createElement(
+        'div',
+        { className: 'modal-content ' + defaultModalClassName },
+        headerComponent || _react2.default.createElement(_InsertModalHeader2.default, {
+          version: this.props.version,
+          className: 'react-bs-table-inser-modal-header',
+          onModalClose: onModalClose }),
+        bodyComponent || _react2.default.createElement(_InsertModalBody2.default, _extends({ ref: 'body' }, bodyAttr)),
+        footerComponent || _react2.default.createElement(_InsertModalFooter2.default, {
+          className: 'react-bs-table-inser-modal-footer',
+          onModalClose: onModalClose,
+          onSave: this.handleSave })
+      );
+    }
+  }]);
+
+  return InsertModal;
+}(_react.Component);
+
+var _default = InsertModal;
+exports.default = _default;
+
+InsertModal.propTypes = {
+  version: _propTypes2.default.string.isRequired,
+  columns: _propTypes2.default.array.isRequired,
+  validateState: _propTypes2.default.object.isRequired,
+  ignoreEditable: _propTypes2.default.bool,
+  headerComponent: _propTypes2.default.func,
+  bodyComponent: _propTypes2.default.func,
+  footerComponent: _propTypes2.default.func,
+  onModalClose: _propTypes2.default.func,
+  onSave: _propTypes2.default.func
+};
+
+InsertModal.defaultProps = {};
+;
+
+var _temp2 = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(defaultModalClassName, 'defaultModalClassName', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/InsertModal.js');
+
+  __REACT_HOT_LOADER__.register(InsertModal, 'InsertModal', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/InsertModal.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/InsertModal.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/toolbar/InsertModalBody.js

@@ -0,0 +1,160 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _Editor = require('../Editor');
+
+var _Editor2 = _interopRequireDefault(_Editor);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; } /* eslint react/display-name: 0 */
+
+
+var InsertModalBody = function (_Component) {
+  _inherits(InsertModalBody, _Component);
+
+  function InsertModalBody() {
+    _classCallCheck(this, InsertModalBody);
+
+    return _possibleConstructorReturn(this, (InsertModalBody.__proto__ || Object.getPrototypeOf(InsertModalBody)).apply(this, arguments));
+  }
+
+  _createClass(InsertModalBody, [{
+    key: 'getFieldValue',
+    value: function getFieldValue() {
+      var _this2 = this;
+
+      var newRow = {};
+      this.props.columns.forEach(function (column, i) {
+        var inputVal = void 0;
+        if (column.autoValue) {
+          // when you want same auto generate value and not allow edit, example ID field
+          var time = new Date().getTime();
+          inputVal = typeof column.autoValue === 'function' ? column.autoValue() : 'autovalue-' + time;
+        } else if (column.hiddenOnInsert || !column.field) {
+          inputVal = '';
+        } else {
+          var dom = _this2.refs[column.field + i];
+          inputVal = dom.value;
+
+          if (column.editable && column.editable.type === 'checkbox') {
+            var values = inputVal.split(':');
+            inputVal = dom.checked ? values[0] : values[1];
+          } else if (column.customInsertEditor) {
+            inputVal = inputVal || dom.getFieldValue();
+          }
+        }
+        newRow[column.field] = inputVal;
+      }, this);
+      return newRow;
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      var _props = this.props,
+          columns = _props.columns,
+          validateState = _props.validateState,
+          ignoreEditable = _props.ignoreEditable;
+
+      return _react2.default.createElement(
+        'div',
+        { className: 'modal-body' },
+        columns.map(function (column, i) {
+          var editable = column.editable,
+              format = column.format,
+              field = column.field,
+              name = column.name,
+              autoValue = column.autoValue,
+              hiddenOnInsert = column.hiddenOnInsert,
+              customInsertEditor = column.customInsertEditor;
+
+          var attr = {
+            ref: field + i,
+            placeholder: editable.placeholder ? editable.placeholder : name
+          };
+          var fieldElement = void 0;
+          var defaultValue = editable.defaultValue || undefined;
+          if (customInsertEditor) {
+            var getElement = customInsertEditor.getElement;
+
+            fieldElement = getElement(column, attr, 'form-control', ignoreEditable, defaultValue);
+          }
+
+          // fieldElement = false, means to use default editor when enable custom editor
+          // Becasuse some users want to have default editor based on some condition.
+          if (!customInsertEditor || fieldElement === false) {
+            fieldElement = (0, _Editor2.default)(editable, attr, format, '', defaultValue, ignoreEditable);
+          }
+
+          if (autoValue || hiddenOnInsert || !column.field) {
+            // when you want same auto generate value
+            // and not allow edit, for example ID field
+            return null;
+          }
+          var error = validateState[field] ? _react2.default.createElement(
+            'span',
+            { className: 'help-block bg-danger' },
+            validateState[field]
+          ) : null;
+          return _react2.default.createElement(
+            'div',
+            { className: 'form-group', key: field },
+            _react2.default.createElement(
+              'label',
+              null,
+              name
+            ),
+            fieldElement,
+            error
+          );
+        })
+      );
+    }
+  }]);
+
+  return InsertModalBody;
+}(_react.Component);
+
+InsertModalBody.propTypes = {
+  columns: _propTypes2.default.array,
+  validateState: _propTypes2.default.object,
+  ignoreEditable: _propTypes2.default.bool
+};
+
+InsertModalBody.defaultProps = {
+  validateState: {},
+  ignoreEditable: false
+};
+
+var _default = InsertModalBody;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(InsertModalBody, 'InsertModalBody', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/InsertModalBody.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/InsertModalBody.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/toolbar/InsertModalFooter.js

@@ -0,0 +1,166 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _Const = require('../Const');
+
+var _Const2 = _interopRequireDefault(_Const);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 InsertModalFooter = function (_Component) {
+  _inherits(InsertModalFooter, _Component);
+
+  function InsertModalFooter() {
+    var _ref;
+
+    var _temp, _this, _ret;
+
+    _classCallCheck(this, InsertModalFooter);
+
+    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = InsertModalFooter.__proto__ || Object.getPrototypeOf(InsertModalFooter)).call.apply(_ref, [this].concat(args))), _this), _this.handleCloseBtnClick = function () {
+      var _this2;
+
+      return (_this2 = _this).__handleCloseBtnClick__REACT_HOT_LOADER__.apply(_this2, arguments);
+    }, _this.handleSaveBtnClick = function () {
+      var _this3;
+
+      return (_this3 = _this).__handleSaveBtnClick__REACT_HOT_LOADER__.apply(_this3, arguments);
+    }, _temp), _possibleConstructorReturn(_this, _ret);
+  }
+
+  _createClass(InsertModalFooter, [{
+    key: '__handleSaveBtnClick__REACT_HOT_LOADER__',
+    value: function __handleSaveBtnClick__REACT_HOT_LOADER__() {
+      return this.__handleSaveBtnClick__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__handleCloseBtnClick__REACT_HOT_LOADER__',
+    value: function __handleCloseBtnClick__REACT_HOT_LOADER__() {
+      return this.__handleCloseBtnClick__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__handleCloseBtnClick__REACT_HOT_LOADER__',
+    value: function __handleCloseBtnClick__REACT_HOT_LOADER__(e) {
+      var _props = this.props,
+          beforeClose = _props.beforeClose,
+          onModalClose = _props.onModalClose;
+
+      beforeClose && beforeClose(e);
+      onModalClose();
+    }
+  }, {
+    key: '__handleSaveBtnClick__REACT_HOT_LOADER__',
+    value: function __handleSaveBtnClick__REACT_HOT_LOADER__(e) {
+      var _props2 = this.props,
+          beforeSave = _props2.beforeSave,
+          onSave = _props2.onSave;
+
+      beforeSave && beforeSave(e);
+      onSave();
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      var _props3 = this.props,
+          className = _props3.className,
+          saveBtnText = _props3.saveBtnText,
+          closeBtnText = _props3.closeBtnText,
+          closeBtnContextual = _props3.closeBtnContextual,
+          saveBtnContextual = _props3.saveBtnContextual,
+          closeBtnClass = _props3.closeBtnClass,
+          saveBtnClass = _props3.saveBtnClass,
+          children = _props3.children;
+
+
+      var content = children || [_react2.default.createElement(
+        'button',
+        {
+          key: 'closeBtn',
+          type: 'button',
+          className: 'btn ' + closeBtnContextual + ' ' + closeBtnClass,
+          onClick: this.handleCloseBtnClick },
+        closeBtnText
+      ), _react2.default.createElement(
+        'button',
+        {
+          key: 'saveBtn',
+          type: 'button',
+          className: 'btn ' + saveBtnContextual + ' ' + saveBtnClass,
+          onClick: this.handleSaveBtnClick },
+        saveBtnText
+      )];
+
+      return _react2.default.createElement(
+        'div',
+        { className: 'modal-footer ' + className },
+        content
+      );
+    }
+  }]);
+
+  return InsertModalFooter;
+}(_react.Component);
+
+InsertModalFooter.propTypes = {
+  className: _propTypes2.default.string,
+  saveBtnText: _propTypes2.default.string,
+  closeBtnText: _propTypes2.default.string,
+  closeBtnContextual: _propTypes2.default.string,
+  saveBtnContextual: _propTypes2.default.string,
+  closeBtnClass: _propTypes2.default.string,
+  saveBtnClass: _propTypes2.default.string,
+  beforeClose: _propTypes2.default.func,
+  beforeSave: _propTypes2.default.func,
+  onSave: _propTypes2.default.func,
+  onModalClose: _propTypes2.default.func
+};
+InsertModalFooter.defaultProps = {
+  className: '',
+  saveBtnText: _Const2.default.SAVE_BTN_TEXT,
+  closeBtnText: _Const2.default.CLOSE_BTN_TEXT,
+  closeBtnContextual: 'btn-default btn-secondary',
+  saveBtnContextual: 'btn-primary',
+  closeBtnClass: '',
+  saveBtnClass: '',
+  beforeClose: undefined,
+  beforeSave: undefined
+};
+
+var _default = InsertModalFooter;
+exports.default = _default;
+;
+
+var _temp2 = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(InsertModalFooter, 'InsertModalFooter', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/InsertModalFooter.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/InsertModalFooter.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/toolbar/InsertModalHeader.js

@@ -0,0 +1,157 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _util = require('../util');
+
+var _util2 = _interopRequireDefault(_util);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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 InsertModalHeader = function (_Component) {
+  _inherits(InsertModalHeader, _Component);
+
+  function InsertModalHeader() {
+    var _ref;
+
+    var _temp, _this, _ret;
+
+    _classCallCheck(this, InsertModalHeader);
+
+    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = InsertModalHeader.__proto__ || Object.getPrototypeOf(InsertModalHeader)).call.apply(_ref, [this].concat(args))), _this), _this.handleCloseBtnClick = function () {
+      var _this2;
+
+      return (_this2 = _this).__handleCloseBtnClick__REACT_HOT_LOADER__.apply(_this2, arguments);
+    }, _temp), _possibleConstructorReturn(_this, _ret);
+  }
+
+  _createClass(InsertModalHeader, [{
+    key: '__handleCloseBtnClick__REACT_HOT_LOADER__',
+    value: function __handleCloseBtnClick__REACT_HOT_LOADER__() {
+      return this.__handleCloseBtnClick__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__handleCloseBtnClick__REACT_HOT_LOADER__',
+    value: function __handleCloseBtnClick__REACT_HOT_LOADER__(e) {
+      var _props = this.props,
+          onModalClose = _props.onModalClose,
+          beforeClose = _props.beforeClose;
+
+      beforeClose && beforeClose(e);
+      onModalClose();
+    }
+  }, {
+    key: 'renderContent',
+    value: function renderContent(closeBtn) {
+      var _props2 = this.props,
+          version = _props2.version,
+          titleText = _props2.title;
+
+      var title = _react2.default.createElement(
+        'h4',
+        { key: 'title', className: 'modal-title' },
+        titleText
+      );
+      if (_util2.default.isBootstrap4(version)) {
+        return [title, closeBtn];
+      } else {
+        return _react2.default.createElement(
+          'span',
+          null,
+          closeBtn,
+          title
+        );
+      }
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      var _props3 = this.props,
+          hideClose = _props3.hideClose,
+          className = _props3.className,
+          children = _props3.children;
+
+
+      var closeBtn = hideClose ? null : _react2.default.createElement(
+        'button',
+        { type: 'button',
+          className: 'close', onClick: this.handleCloseBtnClick },
+        _react2.default.createElement(
+          'span',
+          { 'aria-hidden': 'true' },
+          '\xD7'
+        ),
+        _react2.default.createElement(
+          'span',
+          { className: 'sr-only' },
+          'Close'
+        )
+      );
+
+      var content = children || this.renderContent(closeBtn);
+
+      return _react2.default.createElement(
+        'div',
+        { className: 'modal-header ' + className },
+        content
+      );
+    }
+  }]);
+
+  return InsertModalHeader;
+}(_react.Component);
+
+InsertModalHeader.propTypes = {
+  version: _propTypes2.default.string,
+  className: _propTypes2.default.string,
+  title: _propTypes2.default.string,
+  onModalClose: _propTypes2.default.func,
+  hideClose: _propTypes2.default.bool,
+  beforeClose: _propTypes2.default.func
+};
+InsertModalHeader.defaultProps = {
+  version: '3',
+  className: '',
+  title: 'Add Row',
+  onModalClose: undefined,
+  hideClose: false,
+  beforeClose: undefined
+};
+
+var _default = InsertModalHeader;
+exports.default = _default;
+;
+
+var _temp2 = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(InsertModalHeader, 'InsertModalHeader', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/InsertModalHeader.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/InsertModalHeader.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/toolbar/SearchField.js

@@ -0,0 +1,103 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _reactDom = require('react-dom');
+
+var _reactDom2 = _interopRequireDefault(_reactDom);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+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 SearchField = function (_Component) {
+  _inherits(SearchField, _Component);
+
+  function SearchField() {
+    _classCallCheck(this, SearchField);
+
+    return _possibleConstructorReturn(this, (SearchField.__proto__ || Object.getPrototypeOf(SearchField)).apply(this, arguments));
+  }
+
+  _createClass(SearchField, [{
+    key: 'getValue',
+    value: function getValue() {
+      return _reactDom2.default.findDOMNode(this).value;
+    }
+  }, {
+    key: 'setValue',
+    value: function setValue(value) {
+      _reactDom2.default.findDOMNode(this).value = value;
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      var _props = this.props,
+          className = _props.className,
+          defaultValue = _props.defaultValue,
+          placeholder = _props.placeholder,
+          onKeyUp = _props.onKeyUp,
+          rest = _objectWithoutProperties(_props, ['className', 'defaultValue', 'placeholder', 'onKeyUp']);
+
+      return _react2.default.createElement('input', _extends({
+        className: 'form-control ' + className,
+        type: 'text',
+        defaultValue: defaultValue,
+        placeholder: placeholder || SearchField.defaultProps.placeholder,
+        onKeyUp: onKeyUp,
+        style: { zIndex: 0 }
+      }, rest));
+    }
+  }]);
+
+  return SearchField;
+}(_react.Component);
+
+SearchField.propTypes = {
+  className: _propTypes2.default.string,
+  defaultValue: _propTypes2.default.string,
+  placeholder: _propTypes2.default.string,
+  onKeyUp: _propTypes2.default.func
+};
+SearchField.defaultProps = {
+  className: '',
+  defaultValue: '',
+  placeholder: 'Search',
+  onKeyUp: undefined
+};
+
+var _default = SearchField;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(SearchField, 'SearchField', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/SearchField.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/SearchField.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/toolbar/ShowSelectedOnlyButton.js

@@ -0,0 +1,111 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _Const = require('../Const');
+
+var _Const2 = _interopRequireDefault(_Const);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; }
+
+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 showSelectedOnlyBtnDefaultClass = 'react-bs-table-show-sel-only-btn';
+
+var ShowSelectedOnlyButton = function (_Component) {
+  _inherits(ShowSelectedOnlyButton, _Component);
+
+  function ShowSelectedOnlyButton() {
+    _classCallCheck(this, ShowSelectedOnlyButton);
+
+    return _possibleConstructorReturn(this, (ShowSelectedOnlyButton.__proto__ || Object.getPrototypeOf(ShowSelectedOnlyButton)).apply(this, arguments));
+  }
+
+  _createClass(ShowSelectedOnlyButton, [{
+    key: 'render',
+    value: function render() {
+      var _props = this.props,
+          btnContextual = _props.btnContextual,
+          className = _props.className,
+          onClick = _props.onClick,
+          toggle = _props.toggle,
+          showAllText = _props.showAllText,
+          showOnlySelectText = _props.showOnlySelectText,
+          children = _props.children,
+          rest = _objectWithoutProperties(_props, ['btnContextual', 'className', 'onClick', 'toggle', 'showAllText', 'showOnlySelectText', 'children']);
+
+      var content = children || _react2.default.createElement(
+        'span',
+        null,
+        toggle ? showAllText : showOnlySelectText
+      );
+      return _react2.default.createElement(
+        'button',
+        _extends({ type: 'button',
+          'aria-pressed': 'false',
+          'data-toggle': 'button',
+          className: 'btn ' + btnContextual + ' ' + showSelectedOnlyBtnDefaultClass + ' ' + className,
+          onClick: onClick
+        }, rest),
+        content
+      );
+    }
+  }]);
+
+  return ShowSelectedOnlyButton;
+}(_react.Component);
+
+ShowSelectedOnlyButton.propTypes = {
+  showAllText: _propTypes2.default.string,
+  showOnlySelectText: _propTypes2.default.string,
+  toggle: _propTypes2.default.bool,
+  btnContextual: _propTypes2.default.string,
+  className: _propTypes2.default.string,
+  onClick: _propTypes2.default.func
+};
+ShowSelectedOnlyButton.defaultProps = {
+  showAllText: _Const2.default.SHOW_ALL,
+  showOnlySelectText: _Const2.default.SHOW_ONLY_SELECT,
+  toggle: false,
+  btnContextual: 'btn-primary',
+  className: '',
+  onClick: undefined
+};
+
+var _default = ShowSelectedOnlyButton;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(showSelectedOnlyBtnDefaultClass, 'showSelectedOnlyBtnDefaultClass', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/ShowSelectedOnlyButton.js');
+
+  __REACT_HOT_LOADER__.register(ShowSelectedOnlyButton, 'ShowSelectedOnlyButton', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/ShowSelectedOnlyButton.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/ShowSelectedOnlyButton.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/toolbar/ToolBar.js

@@ -0,0 +1,721 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+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 _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+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; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _reactModal = require('react-modal');
+
+var _reactModal2 = _interopRequireDefault(_reactModal);
+
+var _Const = require('../Const');
+
+var _Const2 = _interopRequireDefault(_Const);
+
+var _Notification = require('../Notification.js');
+
+var _InsertModal = require('./InsertModal');
+
+var _InsertModal2 = _interopRequireDefault(_InsertModal);
+
+var _InsertButton = require('./InsertButton');
+
+var _InsertButton2 = _interopRequireDefault(_InsertButton);
+
+var _DeleteButton = require('./DeleteButton');
+
+var _DeleteButton2 = _interopRequireDefault(_DeleteButton);
+
+var _ExportCSVButton = require('./ExportCSVButton');
+
+var _ExportCSVButton2 = _interopRequireDefault(_ExportCSVButton);
+
+var _ShowSelectedOnlyButton = require('./ShowSelectedOnlyButton');
+
+var _ShowSelectedOnlyButton2 = _interopRequireDefault(_ShowSelectedOnlyButton);
+
+var _SearchField = require('./SearchField');
+
+var _SearchField2 = _interopRequireDefault(_SearchField);
+
+var _ClearSearchButton = require('./ClearSearchButton');
+
+var _ClearSearchButton2 = _interopRequireDefault(_ClearSearchButton);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+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; } /* eslint no-console: 0 */
+
+// import classSet from 'classnames';
+
+// import editor from '../Editor';
+
+
+var ToolBar = function (_Component) {
+  _inherits(ToolBar, _Component);
+
+  function ToolBar(props) {
+    _classCallCheck(this, ToolBar);
+
+    var _this = _possibleConstructorReturn(this, (ToolBar.__proto__ || Object.getPrototypeOf(ToolBar)).call(this, props));
+
+    _this.displayCommonMessage = function () {
+      return _this.__displayCommonMessage__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.handleSaveBtnClick = function () {
+      return _this.__handleSaveBtnClick__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.afterHandleSaveBtnClick = function () {
+      return _this.__afterHandleSaveBtnClick__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.handleModalClose = function () {
+      return _this.__handleModalClose__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.handleModalOpen = function () {
+      return _this.__handleModalOpen__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.handleShowOnlyToggle = function () {
+      return _this.__handleShowOnlyToggle__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.handleDropRowBtnClick = function () {
+      return _this.__handleDropRowBtnClick__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.handleDebounce = function () {
+      return _this.__handleDebounce__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.handleKeyUp = function () {
+      return _this.__handleKeyUp__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.handleExportCSV = function () {
+      return _this.__handleExportCSV__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.handleClearBtnClick = function () {
+      return _this.__handleClearBtnClick__REACT_HOT_LOADER__.apply(_this, arguments);
+    };
+
+    _this.timeouteClear = 0;
+    _this.modalClassName;
+    _this.state = {
+      isInsertModalOpen: false,
+      validateState: null,
+      shakeEditor: false,
+      showSelected: false
+    };
+    return _this;
+  }
+
+  _createClass(ToolBar, [{
+    key: '__handleClearBtnClick__REACT_HOT_LOADER__',
+    value: function __handleClearBtnClick__REACT_HOT_LOADER__() {
+      return this.__handleClearBtnClick__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__handleExportCSV__REACT_HOT_LOADER__',
+    value: function __handleExportCSV__REACT_HOT_LOADER__() {
+      return this.__handleExportCSV__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__handleKeyUp__REACT_HOT_LOADER__',
+    value: function __handleKeyUp__REACT_HOT_LOADER__() {
+      return this.__handleKeyUp__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__handleDebounce__REACT_HOT_LOADER__',
+    value: function __handleDebounce__REACT_HOT_LOADER__(func, wait, immediate) {
+      var _this2 = this,
+          _arguments = arguments;
+
+      var timeout = void 0;
+
+      return function () {
+        var later = function later() {
+          timeout = null;
+
+          if (!immediate) {
+            func.apply(_this2, _arguments);
+          }
+        };
+
+        var callNow = immediate && !timeout;
+
+        clearTimeout(timeout);
+
+        timeout = setTimeout(later, wait || 0);
+
+        if (callNow) {
+          func.appy(_this2, _arguments);
+        }
+      };
+    }
+  }, {
+    key: '__handleDropRowBtnClick__REACT_HOT_LOADER__',
+    value: function __handleDropRowBtnClick__REACT_HOT_LOADER__() {
+      return this.__handleDropRowBtnClick__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__handleShowOnlyToggle__REACT_HOT_LOADER__',
+    value: function __handleShowOnlyToggle__REACT_HOT_LOADER__() {
+      return this.__handleShowOnlyToggle__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__handleModalOpen__REACT_HOT_LOADER__',
+    value: function __handleModalOpen__REACT_HOT_LOADER__() {
+      return this.__handleModalOpen__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__handleModalClose__REACT_HOT_LOADER__',
+    value: function __handleModalClose__REACT_HOT_LOADER__() {
+      return this.__handleModalClose__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__afterHandleSaveBtnClick__REACT_HOT_LOADER__',
+    value: function __afterHandleSaveBtnClick__REACT_HOT_LOADER__() {
+      return this.__afterHandleSaveBtnClick__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__handleSaveBtnClick__REACT_HOT_LOADER__',
+    value: function __handleSaveBtnClick__REACT_HOT_LOADER__() {
+      return this.__handleSaveBtnClick__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: '__displayCommonMessage__REACT_HOT_LOADER__',
+    value: function __displayCommonMessage__REACT_HOT_LOADER__() {
+      return this.__displayCommonMessage__REACT_HOT_LOADER__.apply(this, arguments);
+    }
+  }, {
+    key: 'componentWillMount',
+    value: function componentWillMount() {
+      var _this3 = this;
+
+      var delay = this.props.searchDelayTime ? this.props.searchDelayTime : 0;
+      this.debounceCallback = this.handleDebounce(function () {
+        var seachInput = _this3.refs.seachInput;
+
+        seachInput && _this3.props.onSearch(seachInput.getValue());
+      }, delay);
+    }
+  }, {
+    key: 'componentWillReceiveProps',
+    value: function componentWillReceiveProps(nextProps) {
+      if (nextProps.reset) {
+        this.setSearchInput('');
+      }
+    }
+  }, {
+    key: 'componentWillUnmount',
+    value: function componentWillUnmount() {
+      this.clearTimeout();
+    }
+  }, {
+    key: 'setSearchInput',
+    value: function setSearchInput(text) {
+      var seachInput = this.refs.seachInput;
+
+      if (seachInput && seachInput.value !== text) {
+        seachInput.value = text;
+      }
+    }
+  }, {
+    key: 'clearTimeout',
+    value: function (_clearTimeout) {
+      function clearTimeout() {
+        return _clearTimeout.apply(this, arguments);
+      }
+
+      clearTimeout.toString = function () {
+        return _clearTimeout.toString();
+      };
+
+      return clearTimeout;
+    }(function () {
+      if (this.timeouteClear) {
+        clearTimeout(this.timeouteClear);
+        this.timeouteClear = 0;
+      }
+    })
+  }, {
+    key: '__displayCommonMessage__REACT_HOT_LOADER__',
+    value: function __displayCommonMessage__REACT_HOT_LOADER__() {
+      (0, _Notification.notice)('error', this.props.insertFailIndicator, '');
+    }
+  }, {
+    key: 'validateNewRow',
+    value: function validateNewRow(newRow) {
+      var _this4 = this;
+
+      var validateState = {};
+      var isValid = true;
+      var tempMsg = void 0;
+      var responseType = void 0;
+
+      this.props.columns.forEach(function (column) {
+        if (column.isKey && column.keyValidator) {
+          // key validator for checking exist key
+          tempMsg = _this4.props.isValidKey(newRow[column.field]);
+          if (tempMsg) {
+            _this4.displayCommonMessage();
+            isValid = false;
+            validateState[column.field] = tempMsg;
+          }
+        } else if (column.editable && column.editable.validator) {
+          // process validate
+          tempMsg = column.editable.validator(newRow[column.field], newRow);
+          responseType = typeof tempMsg === 'undefined' ? 'undefined' : _typeof(tempMsg);
+          if (responseType !== 'object' && tempMsg !== true) {
+            _this4.displayCommonMessage();
+            isValid = false;
+            validateState[column.field] = tempMsg;
+          } else if (responseType === 'object' && tempMsg.isValid !== true) {
+            (0, _Notification.notice)(tempMsg.notification.type, tempMsg.notification.msg, tempMsg.notification.title);
+            isValid = false;
+            validateState[column.field] = tempMsg.notification.msg;
+          }
+        }
+      });
+
+      if (isValid) {
+        return true;
+      } else {
+        this.clearTimeout();
+        // show error in form and shake it
+        this.setState(function () {
+          return { validateState: validateState, shakeEditor: true };
+        });
+        this.timeouteClear = setTimeout(function () {
+          _this4.setState(function () {
+            return { shakeEditor: false };
+          });
+        }, 300);
+        return null;
+      }
+    }
+  }, {
+    key: '__handleSaveBtnClick__REACT_HOT_LOADER__',
+    value: function __handleSaveBtnClick__REACT_HOT_LOADER__(newRow) {
+      if (!this.validateNewRow(newRow)) {
+        // validation fail
+        return;
+      }
+      var msg = this.props.onAddRow(newRow);
+      if (msg !== false) {
+        this.afterHandleSaveBtnClick(msg);
+      }
+    }
+  }, {
+    key: '__afterHandleSaveBtnClick__REACT_HOT_LOADER__',
+    value: function __afterHandleSaveBtnClick__REACT_HOT_LOADER__(msg) {
+      var _this5 = this;
+
+      if (msg) {
+        (0, _Notification.notice)('error', msg, '');
+        this.clearTimeout();
+        // shake form and hack prevent modal hide
+        this.setState(function () {
+          return {
+            shakeEditor: true,
+            validateState: 'this is hack for prevent bootstrap modal hide'
+          };
+        });
+        // clear animate class
+        this.timeouteClear = setTimeout(function () {
+          _this5.setState(function () {
+            return { shakeEditor: false };
+          });
+        }, 300);
+      } else {
+        // reset state and hide modal hide
+        this.setState(function () {
+          return {
+            validateState: null,
+            shakeEditor: false,
+            isInsertModalOpen: false
+          };
+        });
+      }
+    }
+  }, {
+    key: '__handleModalClose__REACT_HOT_LOADER__',
+    value: function __handleModalClose__REACT_HOT_LOADER__() {
+      this.setState(function () {
+        return { isInsertModalOpen: false };
+      });
+    }
+  }, {
+    key: '__handleModalOpen__REACT_HOT_LOADER__',
+    value: function __handleModalOpen__REACT_HOT_LOADER__() {
+      this.setState(function () {
+        return { isInsertModalOpen: true };
+      });
+    }
+  }, {
+    key: '__handleShowOnlyToggle__REACT_HOT_LOADER__',
+    value: function __handleShowOnlyToggle__REACT_HOT_LOADER__() {
+      var _this6 = this;
+
+      this.setState(function () {
+        return {
+          showSelected: !_this6.state.showSelected
+        };
+      });
+      this.props.onShowOnlySelected();
+    }
+  }, {
+    key: '__handleDropRowBtnClick__REACT_HOT_LOADER__',
+    value: function __handleDropRowBtnClick__REACT_HOT_LOADER__() {
+      this.props.onDropRow();
+    }
+  }, {
+    key: 'handleCloseBtn',
+    value: function handleCloseBtn() {
+      this.refs.warning.style.display = 'none';
+    }
+  }, {
+    key: '__handleKeyUp__REACT_HOT_LOADER__',
+    value: function __handleKeyUp__REACT_HOT_LOADER__(event) {
+      event.persist();
+      this.debounceCallback(event);
+    }
+  }, {
+    key: '__handleExportCSV__REACT_HOT_LOADER__',
+    value: function __handleExportCSV__REACT_HOT_LOADER__() {
+      this.props.onExportCSV();
+    }
+  }, {
+    key: '__handleClearBtnClick__REACT_HOT_LOADER__',
+    value: function __handleClearBtnClick__REACT_HOT_LOADER__() {
+      var seachInput = this.refs.seachInput;
+
+      seachInput && seachInput.setValue('');
+      this.props.onSearch('');
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      this.modalClassName = 'bs-table-modal-sm' + ToolBar.modalSeq++;
+      var toolbar = null;
+      var btnGroup = null;
+      var insertBtn = null;
+      var deleteBtn = null;
+      var exportCSVBtn = null;
+      var showSelectedOnlyBtn = null;
+
+      if (this.props.enableInsert) {
+        if (this.props.insertBtn) {
+          insertBtn = this.renderCustomBtn(this.props.insertBtn, [this.handleModalOpen], _InsertButton2.default.name, 'onClick', this.handleModalOpen);
+        } else {
+          insertBtn = _react2.default.createElement(_InsertButton2.default, { btnText: this.props.insertText,
+            onClick: this.handleModalOpen });
+        }
+      }
+
+      if (this.props.enableDelete) {
+        if (this.props.deleteBtn) {
+          deleteBtn = this.renderCustomBtn(this.props.deleteBtn, [this.handleDropRowBtnClick], _DeleteButton2.default.name, 'onClick', this.handleDropRowBtnClick);
+        } else {
+          deleteBtn = _react2.default.createElement(_DeleteButton2.default, { btnText: this.props.deleteText,
+            onClick: this.handleDropRowBtnClick });
+        }
+      }
+
+      if (this.props.enableShowOnlySelected) {
+        if (this.props.showSelectedOnlyBtn) {
+          showSelectedOnlyBtn = this.renderCustomBtn(this.props.showSelectedOnlyBtn, [this.handleShowOnlyToggle, this.state.showSelected], _ShowSelectedOnlyButton2.default.name, 'onClick', this.handleShowOnlyToggle);
+        } else {
+          showSelectedOnlyBtn = _react2.default.createElement(_ShowSelectedOnlyButton2.default, { toggle: this.state.showSelected,
+            onClick: this.handleShowOnlyToggle });
+        }
+      }
+
+      if (this.props.enableExportCSV) {
+        if (this.props.exportCSVBtn) {
+          exportCSVBtn = this.renderCustomBtn(this.props.exportCSVBtn, [this.handleExportCSV], _ExportCSVButton2.default.name, 'onClick', this.handleExportCSV);
+        } else {
+          exportCSVBtn = _react2.default.createElement(_ExportCSVButton2.default, { btnText: this.props.exportCSVText,
+            onClick: this.handleExportCSV });
+        }
+      }
+
+      if (this.props.btnGroup) {
+        btnGroup = this.props.btnGroup({
+          exportCSVBtn: exportCSVBtn,
+          insertBtn: insertBtn,
+          deleteBtn: deleteBtn,
+          showSelectedOnlyBtn: showSelectedOnlyBtn
+        });
+      } else {
+        btnGroup = _react2.default.createElement(
+          'div',
+          { className: 'btn-group btn-group-sm', role: 'group' },
+          exportCSVBtn,
+          insertBtn,
+          deleteBtn,
+          showSelectedOnlyBtn
+        );
+      }
+
+      var _renderSearchPanel = this.renderSearchPanel(),
+          _renderSearchPanel2 = _slicedToArray(_renderSearchPanel, 3),
+          searchPanel = _renderSearchPanel2[0],
+          searchField = _renderSearchPanel2[1],
+          clearBtn = _renderSearchPanel2[2];
+
+      var modal = this.props.enableInsert ? this.renderInsertRowModal() : null;
+
+      if (this.props.toolBar) {
+        toolbar = this.props.toolBar({
+          components: {
+            exportCSVBtn: exportCSVBtn,
+            insertBtn: insertBtn,
+            deleteBtn: deleteBtn,
+            showSelectedOnlyBtn: showSelectedOnlyBtn,
+            searchPanel: searchPanel,
+            btnGroup: btnGroup,
+            searchField: searchField,
+            clearBtn: clearBtn
+          },
+          event: {
+            openInsertModal: this.handleModalOpen,
+            closeInsertModal: this.handleModalClose,
+            dropRow: this.handleDropRowBtnClick,
+            showOnlyToogle: this.handleShowOnlyToggle,
+            exportCSV: this.handleExportCSV,
+            search: this.props.onSearch
+          }
+        });
+      } else {
+        toolbar = [_react2.default.createElement(
+          'div',
+          { key: 'toolbar-left', className: 'col-xs-6 col-sm-6 col-md-6 col-lg-8' },
+          this.props.searchPosition === 'left' ? searchPanel : btnGroup
+        ), _react2.default.createElement(
+          'div',
+          { key: 'toolbar-right', className: 'col-xs-6 col-sm-6 col-md-6 col-lg-4' },
+          this.props.searchPosition === 'left' ? btnGroup : searchPanel
+        )];
+      }
+
+      return _react2.default.createElement(
+        'div',
+        { className: 'row' },
+        toolbar,
+        modal
+      );
+    }
+  }, {
+    key: 'renderSearchPanel',
+    value: function renderSearchPanel() {
+      if (this.props.enableSearch) {
+        var classNames = 'form-group form-group-sm react-bs-table-search-form';
+        var clearBtn = null;
+        var searchField = null;
+        var searchPanel = null;
+        if (this.props.clearSearch) {
+          if (this.props.clearSearchBtn) {
+            clearBtn = this.renderCustomBtn(this.props.clearSearchBtn, [this.handleClearBtnClick], _ClearSearchButton2.default.name, 'onClick', this.handleClearBtnClick); /* eslint max-len: 0*/
+          } else {
+            clearBtn = _react2.default.createElement(_ClearSearchButton2.default, { onClick: this.handleClearBtnClick });
+          }
+          classNames += ' input-group input-group-sm';
+        }
+
+        if (this.props.searchField) {
+          searchField = this.props.searchField({
+            search: this.handleKeyUp,
+            defaultValue: this.props.defaultSearch,
+            placeholder: this.props.searchPlaceholder
+          });
+          if (searchField.type.name === _SearchField2.default.name) {
+            searchField = _react2.default.cloneElement(searchField, {
+              ref: 'seachInput',
+              onKeyUp: this.handleKeyUp
+            });
+          } else {
+            searchField = _react2.default.cloneElement(searchField, {
+              ref: 'seachInput'
+            });
+          }
+        } else {
+          searchField = _react2.default.createElement(_SearchField2.default, { ref: 'seachInput',
+            defaultValue: this.props.defaultSearch,
+            placeholder: this.props.searchPlaceholder,
+            onKeyUp: this.handleKeyUp });
+        }
+        if (this.props.searchPanel) {
+          searchPanel = this.props.searchPanel({
+            searchField: searchField, clearBtn: clearBtn,
+            search: this.props.onSearch,
+            defaultValue: this.props.defaultSearch,
+            placeholder: this.props.searchPlaceholder,
+            clearBtnClick: this.handleClearBtnClick
+          });
+        } else {
+          searchPanel = _react2.default.createElement(
+            'div',
+            { className: classNames },
+            searchField,
+            _react2.default.createElement(
+              'span',
+              { className: 'input-group-btn' },
+              clearBtn
+            )
+          );
+        }
+        return [searchPanel, searchField, clearBtn];
+      } else {
+        return [];
+      }
+    }
+  }, {
+    key: 'renderInsertRowModal',
+    value: function renderInsertRowModal() {
+      var validateState = this.state.validateState || {};
+      var _props = this.props,
+          version = _props.version,
+          columns = _props.columns,
+          ignoreEditable = _props.ignoreEditable,
+          insertModalHeader = _props.insertModalHeader,
+          insertModalBody = _props.insertModalBody,
+          insertModalFooter = _props.insertModalFooter,
+          insertModal = _props.insertModal;
+
+
+      var modal = void 0;
+      modal = insertModal && insertModal(this.handleModalClose, this.handleSaveBtnClick, columns, validateState, ignoreEditable);
+
+      if (!modal) {
+        modal = _react2.default.createElement(_InsertModal2.default, {
+          version: version,
+          columns: columns,
+          validateState: validateState,
+          ignoreEditable: ignoreEditable,
+          onModalClose: this.handleModalClose,
+          onSave: this.handleSaveBtnClick,
+          headerComponent: insertModalHeader,
+          bodyComponent: insertModalBody,
+          footerComponent: insertModalFooter });
+      }
+
+      return _react2.default.createElement(
+        _reactModal2.default,
+        { className: 'react-bs-insert-modal modal-dialog',
+          isOpen: this.state.isInsertModalOpen,
+          onRequestClose: this.handleModalClose,
+          contentLabel: 'Modal' },
+        modal
+      );
+    }
+  }, {
+    key: 'renderCustomBtn',
+    value: function renderCustomBtn(cb, params, componentName, eventName, event) {
+      var element = cb.apply(null, params);
+      if (element.type.name === componentName && !element.props[eventName]) {
+        var props = {};
+        props[eventName] = event;
+        element = _react2.default.cloneElement(element, props);
+      }
+      return element;
+    }
+  }]);
+
+  return ToolBar;
+}(_react.Component);
+
+ToolBar.modalSeq = 0;
+
+
+ToolBar.propTypes = {
+  version: _propTypes2.default.string,
+  onAddRow: _propTypes2.default.func,
+  onDropRow: _propTypes2.default.func,
+  onShowOnlySelected: _propTypes2.default.func,
+  enableInsert: _propTypes2.default.bool,
+  enableDelete: _propTypes2.default.bool,
+  enableSearch: _propTypes2.default.bool,
+  enableShowOnlySelected: _propTypes2.default.bool,
+  columns: _propTypes2.default.array,
+  searchPlaceholder: _propTypes2.default.string,
+  exportCSVText: _propTypes2.default.string,
+  insertText: _propTypes2.default.string,
+  deleteText: _propTypes2.default.string,
+  saveText: _propTypes2.default.string,
+  closeText: _propTypes2.default.string,
+  clearSearch: _propTypes2.default.bool,
+  ignoreEditable: _propTypes2.default.bool,
+  defaultSearch: _propTypes2.default.string,
+  insertModalHeader: _propTypes2.default.func,
+  insertModalBody: _propTypes2.default.func,
+  insertModalFooter: _propTypes2.default.func,
+  insertModal: _propTypes2.default.func,
+  insertBtn: _propTypes2.default.func,
+  deleteBtn: _propTypes2.default.func,
+  showSelectedOnlyBtn: _propTypes2.default.func,
+  exportCSVBtn: _propTypes2.default.func,
+  clearSearchBtn: _propTypes2.default.func,
+  searchField: _propTypes2.default.func,
+  searchPanel: _propTypes2.default.func,
+  btnGroup: _propTypes2.default.func,
+  toolBar: _propTypes2.default.func,
+  searchPosition: _propTypes2.default.string,
+  reset: _propTypes2.default.bool,
+  isValidKey: _propTypes2.default.func,
+  insertFailIndicator: _propTypes2.default.string
+};
+
+ToolBar.defaultProps = {
+  reset: false,
+  enableInsert: false,
+  enableDelete: false,
+  enableSearch: false,
+  enableShowOnlySelected: false,
+  clearSearch: false,
+  ignoreEditable: false,
+  exportCSVText: _Const2.default.EXPORT_CSV_TEXT,
+  insertText: _Const2.default.INSERT_BTN_TEXT,
+  deleteText: _Const2.default.DELETE_BTN_TEXT,
+  saveText: _Const2.default.SAVE_BTN_TEXT,
+  closeText: _Const2.default.CLOSE_BTN_TEXT
+};
+
+var _default = ToolBar;
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(ToolBar, 'ToolBar', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/ToolBar.js');
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/toolbar/ToolBar.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/lib/util.js

@@ -0,0 +1,153 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _Const = require('./Const');
+
+var _Const2 = _interopRequireDefault(_Const);
+
+var _classnames = require('classnames');
+
+var _classnames2 = _interopRequireDefault(_classnames);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _default = {
+  renderReactSortCaret: function renderReactSortCaret(order, isBootstrap4) {
+    var orderClass = void 0;
+    if (isBootstrap4) {
+      orderClass = (0, _classnames2.default)('fa', {
+        'fa-sort-asc': order === _Const2.default.SORT_ASC,
+        'fa-sort-desc': order === _Const2.default.SORT_DESC
+      });
+      return _react2.default.createElement('span', { className: orderClass, style: { margin: '10px 5px' } });
+    } else {
+      orderClass = (0, _classnames2.default)('order', {
+        'dropup': order === _Const2.default.SORT_ASC
+      });
+      return _react2.default.createElement(
+        'span',
+        { className: orderClass },
+        _react2.default.createElement('span', { className: 'caret', style: { margin: '10px 5px' } })
+      );
+    }
+  },
+  isFunction: function isFunction(obj) {
+    return obj && typeof obj === 'function';
+  },
+  getScrollBarWidth: function getScrollBarWidth() {
+    var inner = document.createElement('p');
+    inner.style.width = '100%';
+    inner.style.height = '200px';
+
+    var outer = document.createElement('div');
+    outer.style.position = 'absolute';
+    outer.style.top = '0px';
+    outer.style.left = '0px';
+    outer.style.visibility = 'hidden';
+    outer.style.width = '200px';
+    outer.style.height = '150px';
+    outer.style.overflow = 'hidden';
+    outer.appendChild(inner);
+
+    document.body.appendChild(outer);
+    var w1 = inner.getBoundingClientRect().width;
+    outer.style.overflow = 'scroll';
+    var w2 = inner.getBoundingClientRect().width;
+
+    if (w1 === w2) w2 = outer.clientWidth;
+
+    document.body.removeChild(outer);
+
+    return w1 - w2;
+  },
+  canUseDOM: function canUseDOM() {
+    return typeof window !== 'undefined' && typeof window.document !== 'undefined';
+  },
+
+
+  // We calculate an offset here in order to properly fetch the indexed data,
+  // despite the page start index not always being 1
+  getNormalizedPage: function getNormalizedPage(pageStartIndex, page) {
+    pageStartIndex = this.getFirstPage(pageStartIndex);
+    if (page === undefined) page = pageStartIndex;
+    var offset = Math.abs(_Const2.default.PAGE_START_INDEX - pageStartIndex);
+    return page + offset;
+  },
+  getFirstPage: function getFirstPage(pageStartIndex) {
+    return pageStartIndex !== undefined ? pageStartIndex : _Const2.default.PAGE_START_INDEX;
+  },
+  isBootstrap4: function isBootstrap4(version) {
+    return version === '4';
+  },
+  isSelectRowDefined: function isSelectRowDefined(mode) {
+    return mode === _Const2.default.ROW_SELECT_SINGLE || mode === _Const2.default.ROW_SELECT_MULTI;
+  },
+  renderColGroup: function renderColGroup(columns, selectRow) {
+    var expandColumnOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    var version = arguments[3];
+
+    var selectRowHeader = null;
+    var expandRowHeader = null;
+    var isBootstrap4 = this.isBootstrap4(version);
+    var isSelectRowDefined = this.isSelectRowDefined(selectRow.mode);
+    var columnWidth = isBootstrap4 ? '38px' : '30px';
+    if (isSelectRowDefined) {
+      var style = {
+        width: selectRow.columnWidth || columnWidth,
+        minWidth: selectRow.columnWidth || columnWidth
+      };
+      if (!selectRow.hideSelectColumn) {
+        selectRowHeader = _react2.default.createElement('col', { key: 'select-col', style: style });
+      }
+    }
+    if (expandColumnOptions.expandColumnVisible) {
+      var _style = {
+        width: expandColumnOptions.columnWidth || columnWidth,
+        minWidth: expandColumnOptions.columnWidth || columnWidth
+      };
+      expandRowHeader = _react2.default.createElement('col', { key: 'expand-col', style: _style });
+    }
+    var theader = columns.map(function (column, i) {
+      var style = {
+        display: column.hidden ? 'none' : null
+      };
+      if (column.width) {
+        var width = !isNaN(column.width) ? column.width + 'px' : column.width;
+        style.width = width;
+        /** add min-wdth to fix user assign column width
+        not eq offsetWidth in large column table **/
+        style.minWidth = width;
+      }
+      return _react2.default.createElement('col', { style: style, key: i });
+    });
+
+    return _react2.default.createElement(
+      'colgroup',
+      null,
+      expandColumnOptions.expandColumnVisible && expandColumnOptions.expandColumnBeforeSelectColumn && expandRowHeader,
+      selectRowHeader,
+      expandColumnOptions.expandColumnVisible && !expandColumnOptions.expandColumnBeforeSelectColumn && expandRowHeader,
+      theader
+    );
+  }
+}; /* eslint react/display-name: 0 */
+
+exports.default = _default;
+;
+
+var _temp = function () {
+  if (typeof __REACT_HOT_LOADER__ === 'undefined') {
+    return;
+  }
+
+  __REACT_HOT_LOADER__.register(_default, 'default', '/Users/allen/Node/react-bootstrap-table-new/react-bootstrap-table/src/util.js');
+}();
+
+;

torrent-project/node_modules/react-bootstrap-table/node_modules/.bin/loose-envify

@@ -0,0 +1,15 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*) basedir=`cygpath -w "$basedir"`;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  "$basedir/node"  "$basedir/../loose-envify/cli.js" "$@"
+  ret=$?
+else 
+  node  "$basedir/../loose-envify/cli.js" "$@"
+  ret=$?
+fi
+exit $ret

torrent-project/node_modules/react-bootstrap-table/node_modules/.bin/loose-envify.cmd

@@ -0,0 +1,7 @@
+@IF EXIST "%~dp0\node.exe" (
+  "%~dp0\node.exe"  "%~dp0\..\loose-envify\cli.js" %*
+) ELSE (
+  @SETLOCAL
+  @SET PATHEXT=%PATHEXT:;.JS;=;%
+  node  "%~dp0\..\loose-envify\cli.js" %*
+)

torrent-project/node_modules/react-bootstrap-table/node_modules/asap/CHANGES.md

@@ -0,0 +1,70 @@
+
+## 2.0.6
+
+Version 2.0.4 adds support for React Native by clarifying in package.json that
+the browser environment does not support Node.js domains.
+Why this is necessary, we leave as an exercise for the user.
+
+## 2.0.3
+
+Version 2.0.3 fixes a bug when adjusting the capacity of the task queue.
+
+## 2.0.1-2.02
+
+Version 2.0.1 fixes a bug in the way redirects were expressed that affected the
+function of Browserify, but which Mr would tolerate.
+
+## 2.0.0
+
+Version 2 of ASAP is a full rewrite with a few salient changes.
+First, the ASAP source is CommonJS only and designed with [Browserify][] and
+[Browserify-compatible][Mr] module loaders in mind.
+
+[Browserify]: https://github.com/substack/node-browserify
+[Mr]: https://github.com/montagejs/mr
+
+The new version has been refactored in two dimensions.
+Support for Node.js and browsers have been separated, using Browserify
+redirects and ASAP has been divided into two modules.
+The "raw" layer depends on the tasks to catch thrown exceptions and unravel
+Node.js domains.
+
+The full implementation of ASAP is loadable as `require("asap")` in both Node.js
+and browsers.
+
+The raw layer that lacks exception handling overhead is loadable as
+`require("asap/raw")`.
+The interface is the same for both layers.
+
+Tasks are no longer required to be functions, but can rather be any object that
+implements `task.call()`.
+With this feature you can recycle task objects to avoid garbage collector churn
+and avoid closures in general.
+
+The implementation has been rigorously documented so that our successors can
+understand the scope of the problem that this module solves and all of its
+nuances, ensuring that the next generation of implementations know what details
+are essential.
+
+-   [asap.js](https://github.com/kriskowal/asap/blob/master/asap.js)
+-   [raw.js](https://github.com/kriskowal/asap/blob/master/raw.js)
+-   [browser-asap.js](https://github.com/kriskowal/asap/blob/master/browser-asap.js)
+-   [browser-raw.js](https://github.com/kriskowal/asap/blob/master/browser-raw.js)
+
+The new version has also been rigorously tested across a broad spectrum of
+browsers, in both the window and worker context.
+The following charts capture the browser test results for the most recent
+release.
+The first chart shows test results for ASAP running in the main window context.
+The second chart shows test results for ASAP running in a web worker context.
+Test results are inconclusive (grey) on browsers that do not support web
+workers.
+These data are captured automatically by [Continuous
+Integration][].
+
+![Browser Compatibility](http://kriskowal-asap.s3-website-us-west-2.amazonaws.com/train/integration-2/saucelabs-results-matrix.svg)
+
+![Compatibility in Web Workers](http://kriskowal-asap.s3-website-us-west-2.amazonaws.com/train/integration-2/saucelabs-worker-results-matrix.svg)
+
+[Continuous Integration]: https://github.com/kriskowal/asap/blob/master/CONTRIBUTING.md
+

torrent-project/node_modules/react-bootstrap-table/node_modules/asap/LICENSE.md

@@ -0,0 +1,21 @@
+
+Copyright 2009–2014 Contributors. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.
+

torrent-project/node_modules/react-bootstrap-table/node_modules/asap/README.md

@@ -0,0 +1,237 @@
+# ASAP
+
+[![Build Status](https://travis-ci.org/kriskowal/asap.png?branch=master)](https://travis-ci.org/kriskowal/asap)
+
+Promise and asynchronous observer libraries, as well as hand-rolled callback
+programs and libraries, often need a mechanism to postpone the execution of a
+callback until the next available event.
+(See [Designing API’s for Asynchrony][Zalgo].)
+The `asap` function executes a task **as soon as possible** but not before it
+returns, waiting only for the completion of the current event and previously
+scheduled tasks.
+
+```javascript
+asap(function () {
+    // ...
+});
+```
+
+[Zalgo]: http://blog.izs.me/post/59142742143/designing-apis-for-asynchrony
+
+This CommonJS package provides an `asap` module that exports a function that
+executes a task function *as soon as possible*.
+
+ASAP strives to schedule events to occur before yielding for IO, reflow,
+or redrawing.
+Each event receives an independent stack, with only platform code in parent
+frames and the events run in the order they are scheduled.
+
+ASAP provides a fast event queue that will execute tasks until it is
+empty before yielding to the JavaScript engine's underlying event-loop.
+When a task gets added to a previously empty event queue, ASAP schedules a flush
+event, preferring for that event to occur before the JavaScript engine has an
+opportunity to perform IO tasks or rendering, thus making the first task and
+subsequent tasks semantically indistinguishable.
+ASAP uses a variety of techniques to preserve this invariant on different
+versions of browsers and Node.js.
+
+By design, ASAP prevents input events from being handled until the task
+queue is empty.
+If the process is busy enough, this may cause incoming connection requests to be
+dropped, and may cause existing connections to inform the sender to reduce the
+transmission rate or stall.
+ASAP allows this on the theory that, if there is enough work to do, there is no
+sense in looking for trouble.
+As a consequence, ASAP can interfere with smooth animation.
+If your task should be tied to the rendering loop, consider using
+`requestAnimationFrame` instead.
+A long sequence of tasks can also effect the long running script dialog.
+If this is a problem, you may be able to use ASAP’s cousin `setImmediate` to
+break long processes into shorter intervals and periodically allow the browser
+to breathe.
+`setImmediate` will yield for IO, reflow, and repaint events.
+It also returns a handler and can be canceled.
+For a `setImmediate` shim, consider [YuzuJS setImmediate][setImmediate].
+
+[setImmediate]: https://github.com/YuzuJS/setImmediate
+
+Take care.
+ASAP can sustain infinite recursive calls without warning.
+It will not halt from a stack overflow, and it will not consume unbounded
+memory.
+This is behaviorally equivalent to an infinite loop.
+Just as with infinite loops, you can monitor a Node.js process for this behavior
+with a heart-beat signal.
+As with infinite loops, a very small amount of caution goes a long way to
+avoiding problems.
+
+```javascript
+function loop() {
+    asap(loop);
+}
+loop();
+```
+
+In browsers, if a task throws an exception, it will not interrupt the flushing
+of high-priority tasks.
+The exception will be postponed to a later, low-priority event to avoid
+slow-downs.
+In Node.js, if a task throws an exception, ASAP will resume flushing only if—and
+only after—the error is handled by `domain.on("error")` or
+`process.on("uncaughtException")`.
+
+## Raw ASAP
+
+Checking for exceptions comes at a cost.
+The package also provides an `asap/raw` module that exports the underlying
+implementation which is faster but stalls if a task throws an exception.
+This internal version of the ASAP function does not check for errors.
+If a task does throw an error, it will stall the event queue unless you manually
+call `rawAsap.requestFlush()` before throwing the error, or any time after.
+
+In Node.js, `asap/raw` also runs all tasks outside any domain.
+If you need a task to be bound to your domain, you will have to do it manually.
+
+```js
+if (process.domain) {
+    task = process.domain.bind(task);
+}
+rawAsap(task);
+```
+
+## Tasks
+
+A task may be any object that implements `call()`.
+A function will suffice, but closures tend not to be reusable and can cause
+garbage collector churn.
+Both `asap` and `rawAsap` accept task objects to give you the option of
+recycling task objects or using higher callable object abstractions.
+See the `asap` source for an illustration.
+
+
+## Compatibility
+
+ASAP is tested on Node.js v0.10 and in a broad spectrum of web browsers.
+The following charts capture the browser test results for the most recent
+release.
+The first chart shows test results for ASAP running in the main window context.
+The second chart shows test results for ASAP running in a web worker context.
+Test results are inconclusive (grey) on browsers that do not support web
+workers.
+These data are captured automatically by [Continuous
+Integration][].
+
+[Continuous Integration]: https://github.com/kriskowal/asap/blob/master/CONTRIBUTING.md
+
+![Browser Compatibility](http://kriskowal-asap.s3-website-us-west-2.amazonaws.com/train/integration-2/saucelabs-results-matrix.svg)
+
+![Compatibility in Web Workers](http://kriskowal-asap.s3-website-us-west-2.amazonaws.com/train/integration-2/saucelabs-worker-results-matrix.svg)
+
+## Caveats
+
+When a task is added to an empty event queue, it is not always possible to
+guarantee that the task queue will begin flushing immediately after the current
+event.
+However, once the task queue begins flushing, it will not yield until the queue
+is empty, even if the queue grows while executing tasks.
+
+The following browsers allow the use of [DOM mutation observers][] to access
+the HTML [microtask queue][], and thus begin flushing ASAP's task queue
+immediately at the end of the current event loop turn, before any rendering or
+IO:
+
+[microtask queue]: http://www.whatwg.org/specs/web-apps/current-work/multipage/webappapis.html#microtask-queue
+[DOM mutation observers]: http://dom.spec.whatwg.org/#mutation-observers
+
+- Android 4–4.3
+- Chrome 26–34
+- Firefox 14–29
+- Internet Explorer 11
+- iPad Safari 6–7.1
+- iPhone Safari 7–7.1
+- Safari 6–7
+
+In the absense of mutation observers, there are a few browsers, and situations
+like web workers in some of the above browsers,  where [message channels][]
+would be a useful way to avoid falling back to timers.
+Message channels give direct access to the HTML [task queue][], so the ASAP
+task queue would flush after any already queued rendering and IO tasks, but
+without having the minimum delay imposed by timers.
+However, among these browsers, Internet Explorer 10 and Safari do not reliably
+dispatch messages, so they are not worth the trouble to implement.
+
+[message channels]: http://www.whatwg.org/specs/web-apps/current-work/multipage/web-messaging.html#message-channels
+[task queue]: http://www.whatwg.org/specs/web-apps/current-work/multipage/webappapis.html#concept-task
+
+- Internet Explorer 10
+- Safair 5.0-1
+- Opera 11-12
+
+In the absense of mutation observers, these browsers and the following browsers
+all fall back to using `setTimeout` and `setInterval` to ensure that a `flush`
+occurs.
+The implementation uses both and cancels whatever handler loses the race, since
+`setTimeout` tends to occasionally skip tasks in unisolated circumstances.
+Timers generally delay the flushing of ASAP's task queue for four milliseconds.
+
+- Firefox 3–13
+- Internet Explorer 6–10
+- iPad Safari 4.3
+- Lynx 2.8.7
+
+
+## Heritage
+
+ASAP has been factored out of the [Q][] asynchronous promise library.
+It originally had a naïve implementation in terms of `setTimeout`, but
+[Malte Ubl][NonBlocking] provided an insight that `postMessage` might be
+useful for creating a high-priority, no-delay event dispatch hack.
+Since then, Internet Explorer proposed and implemented `setImmediate`.
+Robert Katić began contributing to Q by measuring the performance of
+the internal implementation of `asap`, paying particular attention to
+error recovery.
+Domenic, Robert, and Kris Kowal collectively settled on the current strategy of
+unrolling the high-priority event queue internally regardless of what strategy
+we used to dispatch the potentially lower-priority flush event.
+Domenic went on to make ASAP cooperate with Node.js domains.
+
+[Q]: https://github.com/kriskowal/q
+[NonBlocking]: http://www.nonblocking.io/2011/06/windownexttick.html
+
+For further reading, Nicholas Zakas provided a thorough article on [The
+Case for setImmediate][NCZ].
+
+[NCZ]: http://www.nczonline.net/blog/2013/07/09/the-case-for-setimmediate/
+
+Ember’s RSVP promise implementation later [adopted][RSVP ASAP] the name ASAP but
+further developed the implentation.
+Particularly, The `MessagePort` implementation was abandoned due to interaction
+[problems with Mobile Internet Explorer][IE Problems] in favor of an
+implementation backed on the newer and more reliable DOM `MutationObserver`
+interface.
+These changes were back-ported into this library.
+
+[IE Problems]: https://github.com/cujojs/when/issues/197
+[RSVP ASAP]: https://github.com/tildeio/rsvp.js/blob/cddf7232546a9cf858524b75cde6f9edf72620a7/lib/rsvp/asap.js
+
+In addition, ASAP factored into `asap` and `asap/raw`, such that `asap` remained
+exception-safe, but `asap/raw` provided a tight kernel that could be used for
+tasks that guaranteed that they would not throw exceptions.
+This core is useful for promise implementations that capture thrown errors in
+rejected promises and do not need a second safety net.
+At the same time, the exception handling in `asap` was factored into separate
+implementations for Node.js and browsers, using the the [Browserify][Browser
+Config] `browser` property in `package.json` to instruct browser module loaders
+and bundlers, including [Browserify][], [Mr][], and [Mop][],  to use the
+browser-only implementation.
+
+[Browser Config]: https://gist.github.com/defunctzombie/4339901
+[Browserify]: https://github.com/substack/node-browserify
+[Mr]: https://github.com/montagejs/mr
+[Mop]: https://github.com/montagejs/mop
+
+## License
+
+Copyright 2009-2014 by Contributors
+MIT License (enclosed)
+

torrent-project/node_modules/react-bootstrap-table/node_modules/asap/asap.js

@@ -0,0 +1,65 @@
+"use strict";
+
+var rawAsap = require("./raw");
+var freeTasks = [];
+
+/**
+ * Calls a task as soon as possible after returning, in its own event, with
+ * priority over IO events. An exception thrown in a task can be handled by
+ * `process.on("uncaughtException") or `domain.on("error")`, but will otherwise
+ * crash the process. If the error is handled, all subsequent tasks will
+ * resume.
+ *
+ * @param {{call}} task A callable object, typically a function that takes no
+ * arguments.
+ */
+module.exports = asap;
+function asap(task) {
+    var rawTask;
+    if (freeTasks.length) {
+        rawTask = freeTasks.pop();
+    } else {
+        rawTask = new RawTask();
+    }
+    rawTask.task = task;
+    rawTask.domain = process.domain;
+    rawAsap(rawTask);
+}
+
+function RawTask() {
+    this.task = null;
+    this.domain = null;
+}
+
+RawTask.prototype.call = function () {
+    if (this.domain) {
+        this.domain.enter();
+    }
+    var threw = true;
+    try {
+        this.task.call();
+        threw = false;
+        // If the task throws an exception (presumably) Node.js restores the
+        // domain stack for the next event.
+        if (this.domain) {
+            this.domain.exit();
+        }
+    } finally {
+        // We use try/finally and a threw flag to avoid messing up stack traces
+        // when we catch and release errors.
+        if (threw) {
+            // In Node.js, uncaught exceptions are considered fatal errors.
+            // Re-throw them to interrupt flushing!
+            // Ensure that flushing continues if an uncaught exception is
+            // suppressed listening process.on("uncaughtException") or
+            // domain.on("error").
+            rawAsap.requestFlush();
+        }
+        // If the task threw an error, we do not want to exit the domain here.
+        // Exiting the domain would prevent the domain from catching the error.
+        this.task = null;
+        this.domain = null;
+        freeTasks.push(this);
+    }
+};
+

torrent-project/node_modules/react-bootstrap-table/node_modules/asap/browser-asap.js

@@ -0,0 +1,66 @@
+"use strict";
+
+// rawAsap provides everything we need except exception management.
+var rawAsap = require("./raw");
+// RawTasks are recycled to reduce GC churn.
+var freeTasks = [];
+// We queue errors to ensure they are thrown in right order (FIFO).
+// Array-as-queue is good enough here, since we are just dealing with exceptions.
+var pendingErrors = [];
+var requestErrorThrow = rawAsap.makeRequestCallFromTimer(throwFirstError);
+
+function throwFirstError() {
+    if (pendingErrors.length) {
+        throw pendingErrors.shift();
+    }
+}
+
+/**
+ * Calls a task as soon as possible after returning, in its own event, with priority
+ * over other events like animation, reflow, and repaint. An error thrown from an
+ * event will not interrupt, nor even substantially slow down the processing of
+ * other events, but will be rather postponed to a lower priority event.
+ * @param {{call}} task A callable object, typically a function that takes no
+ * arguments.
+ */
+module.exports = asap;
+function asap(task) {
+    var rawTask;
+    if (freeTasks.length) {
+        rawTask = freeTasks.pop();
+    } else {
+        rawTask = new RawTask();
+    }
+    rawTask.task = task;
+    rawAsap(rawTask);
+}
+
+// We wrap tasks with recyclable task objects.  A task object implements
+// `call`, just like a function.
+function RawTask() {
+    this.task = null;
+}
+
+// The sole purpose of wrapping the task is to catch the exception and recycle
+// the task object after its single use.
+RawTask.prototype.call = function () {
+    try {
+        this.task.call();
+    } catch (error) {
+        if (asap.onerror) {
+            // This hook exists purely for testing purposes.
+            // Its name will be periodically randomized to break any code that
+            // depends on its existence.
+            asap.onerror(error);
+        } else {
+            // In a web browser, exceptions are not fatal. However, to avoid
+            // slowing down the queue of pending tasks, we rethrow the error in a
+            // lower priority turn.
+            pendingErrors.push(error);
+            requestErrorThrow();
+        }
+    } finally {
+        this.task = null;
+        freeTasks[freeTasks.length] = this;
+    }
+};

torrent-project/node_modules/react-bootstrap-table/node_modules/asap/browser-raw.js

@@ -0,0 +1,223 @@
+"use strict";
+
+// Use the fastest means possible to execute a task in its own turn, with
+// priority over other events including IO, animation, reflow, and redraw
+// events in browsers.
+//
+// An exception thrown by a task will permanently interrupt the processing of
+// subsequent tasks. The higher level `asap` function ensures that if an
+// exception is thrown by a task, that the task queue will continue flushing as
+// soon as possible, but if you use `rawAsap` directly, you are responsible to
+// either ensure that no exceptions are thrown from your task, or to manually
+// call `rawAsap.requestFlush` if an exception is thrown.
+module.exports = rawAsap;
+function rawAsap(task) {
+    if (!queue.length) {
+        requestFlush();
+        flushing = true;
+    }
+    // Equivalent to push, but avoids a function call.
+    queue[queue.length] = task;
+}
+
+var queue = [];
+// Once a flush has been requested, no further calls to `requestFlush` are
+// necessary until the next `flush` completes.
+var flushing = false;
+// `requestFlush` is an implementation-specific method that attempts to kick
+// off a `flush` event as quickly as possible. `flush` will attempt to exhaust
+// the event queue before yielding to the browser's own event loop.
+var requestFlush;
+// The position of the next task to execute in the task queue. This is
+// preserved between calls to `flush` so that it can be resumed if
+// a task throws an exception.
+var index = 0;
+// If a task schedules additional tasks recursively, the task queue can grow
+// unbounded. To prevent memory exhaustion, the task queue will periodically
+// truncate already-completed tasks.
+var capacity = 1024;
+
+// The flush function processes all tasks that have been scheduled with
+// `rawAsap` unless and until one of those tasks throws an exception.
+// If a task throws an exception, `flush` ensures that its state will remain
+// consistent and will resume where it left off when called again.
+// However, `flush` does not make any arrangements to be called again if an
+// exception is thrown.
+function flush() {
+    while (index < queue.length) {
+        var currentIndex = index;
+        // Advance the index before calling the task. This ensures that we will
+        // begin flushing on the next task the task throws an error.
+        index = index + 1;
+        queue[currentIndex].call();
+        // Prevent leaking memory for long chains of recursive calls to `asap`.
+        // If we call `asap` within tasks scheduled by `asap`, the queue will
+        // grow, but to avoid an O(n) walk for every task we execute, we don't
+        // shift tasks off the queue after they have been executed.
+        // Instead, we periodically shift 1024 tasks off the queue.
+        if (index > capacity) {
+            // Manually shift all values starting at the index back to the
+            // beginning of the queue.
+            for (var scan = 0, newLength = queue.length - index; scan < newLength; scan++) {
+                queue[scan] = queue[scan + index];
+            }
+            queue.length -= index;
+            index = 0;
+        }
+    }
+    queue.length = 0;
+    index = 0;
+    flushing = false;
+}
+
+// `requestFlush` is implemented using a strategy based on data collected from
+// every available SauceLabs Selenium web driver worker at time of writing.
+// https://docs.google.com/spreadsheets/d/1mG-5UYGup5qxGdEMWkhP6BWCz053NUb2E1QoUTU16uA/edit#gid=783724593
+
+// Safari 6 and 6.1 for desktop, iPad, and iPhone are the only browsers that
+// have WebKitMutationObserver but not un-prefixed MutationObserver.
+// Must use `global` or `self` instead of `window` to work in both frames and web
+// workers. `global` is a provision of Browserify, Mr, Mrs, or Mop.
+
+/* globals self */
+var scope = typeof global !== "undefined" ? global : self;
+var BrowserMutationObserver = scope.MutationObserver || scope.WebKitMutationObserver;
+
+// MutationObservers are desirable because they have high priority and work
+// reliably everywhere they are implemented.
+// They are implemented in all modern browsers.
+//
+// - Android 4-4.3
+// - Chrome 26-34
+// - Firefox 14-29
+// - Internet Explorer 11
+// - iPad Safari 6-7.1
+// - iPhone Safari 7-7.1
+// - Safari 6-7
+if (typeof BrowserMutationObserver === "function") {
+    requestFlush = makeRequestCallFromMutationObserver(flush);
+
+// MessageChannels are desirable because they give direct access to the HTML
+// task queue, are implemented in Internet Explorer 10, Safari 5.0-1, and Opera
+// 11-12, and in web workers in many engines.
+// Although message channels yield to any queued rendering and IO tasks, they
+// would be better than imposing the 4ms delay of timers.
+// However, they do not work reliably in Internet Explorer or Safari.
+
+// Internet Explorer 10 is the only browser that has setImmediate but does
+// not have MutationObservers.
+// Although setImmediate yields to the browser's renderer, it would be
+// preferrable to falling back to setTimeout since it does not have
+// the minimum 4ms penalty.
+// Unfortunately there appears to be a bug in Internet Explorer 10 Mobile (and
+// Desktop to a lesser extent) that renders both setImmediate and
+// MessageChannel useless for the purposes of ASAP.
+// https://github.com/kriskowal/q/issues/396
+
+// Timers are implemented universally.
+// We fall back to timers in workers in most engines, and in foreground
+// contexts in the following browsers.
+// However, note that even this simple case requires nuances to operate in a
+// broad spectrum of browsers.
+//
+// - Firefox 3-13
+// - Internet Explorer 6-9
+// - iPad Safari 4.3
+// - Lynx 2.8.7
+} else {
+    requestFlush = makeRequestCallFromTimer(flush);
+}
+
+// `requestFlush` requests that the high priority event queue be flushed as
+// soon as possible.
+// This is useful to prevent an error thrown in a task from stalling the event
+// queue if the exception handled by Node.js’s
+// `process.on("uncaughtException")` or by a domain.
+rawAsap.requestFlush = requestFlush;
+
+// To request a high priority event, we induce a mutation observer by toggling
+// the text of a text node between "1" and "-1".
+function makeRequestCallFromMutationObserver(callback) {
+    var toggle = 1;
+    var observer = new BrowserMutationObserver(callback);
+    var node = document.createTextNode("");
+    observer.observe(node, {characterData: true});
+    return function requestCall() {
+        toggle = -toggle;
+        node.data = toggle;
+    };
+}
+
+// The message channel technique was discovered by Malte Ubl and was the
+// original foundation for this library.
+// http://www.nonblocking.io/2011/06/windownexttick.html
+
+// Safari 6.0.5 (at least) intermittently fails to create message ports on a
+// page's first load. Thankfully, this version of Safari supports
+// MutationObservers, so we don't need to fall back in that case.
+
+// function makeRequestCallFromMessageChannel(callback) {
+//     var channel = new MessageChannel();
+//     channel.port1.onmessage = callback;
+//     return function requestCall() {
+//         channel.port2.postMessage(0);
+//     };
+// }
+
+// For reasons explained above, we are also unable to use `setImmediate`
+// under any circumstances.
+// Even if we were, there is another bug in Internet Explorer 10.
+// It is not sufficient to assign `setImmediate` to `requestFlush` because
+// `setImmediate` must be called *by name* and therefore must be wrapped in a
+// closure.
+// Never forget.
+
+// function makeRequestCallFromSetImmediate(callback) {
+//     return function requestCall() {
+//         setImmediate(callback);
+//     };
+// }
+
+// Safari 6.0 has a problem where timers will get lost while the user is
+// scrolling. This problem does not impact ASAP because Safari 6.0 supports
+// mutation observers, so that implementation is used instead.
+// However, if we ever elect to use timers in Safari, the prevalent work-around
+// is to add a scroll event listener that calls for a flush.
+
+// `setTimeout` does not call the passed callback if the delay is less than
+// approximately 7 in web workers in Firefox 8 through 18, and sometimes not
+// even then.
+
+function makeRequestCallFromTimer(callback) {
+    return function requestCall() {
+        // We dispatch a timeout with a specified delay of 0 for engines that
+        // can reliably accommodate that request. This will usually be snapped
+        // to a 4 milisecond delay, but once we're flushing, there's no delay
+        // between events.
+        var timeoutHandle = setTimeout(handleTimer, 0);
+        // However, since this timer gets frequently dropped in Firefox
+        // workers, we enlist an interval handle that will try to fire
+        // an event 20 times per second until it succeeds.
+        var intervalHandle = setInterval(handleTimer, 50);
+
+        function handleTimer() {
+            // Whichever timer succeeds will cancel both timers and
+            // execute the callback.
+            clearTimeout(timeoutHandle);
+            clearInterval(intervalHandle);
+            callback();
+        }
+    };
+}
+
+// This is for `asap.js` only.
+// Its name will be periodically randomized to break any code that depends on
+// its existence.
+rawAsap.makeRequestCallFromTimer = makeRequestCallFromTimer;
+
+// ASAP was originally a nextTick shim included in Q. This was factored out
+// into this ASAP package. It was later adapted to RSVP which made further
+// amendments. These decisions, particularly to marginalize MessageChannel and
+// to capture the MutationObserver implementation in a closure, were integrated
+// back into ASAP proper.
+// https://github.com/tildeio/rsvp.js/blob/cddf7232546a9cf858524b75cde6f9edf72620a7/lib/rsvp/asap.js

torrent-project/node_modules/react-bootstrap-table/node_modules/asap/package.json

@@ -0,0 +1,90 @@
+{
+  "_args": [
+    [
+      "asap@2.0.6",
+      "C:\\Users\\deranjer\\GoglandProjects\\torrent-project\\torrent-project"
+    ]
+  ],
+  "_from": "asap@2.0.6",
+  "_id": "asap@2.0.6",
+  "_inBundle": false,
+  "_integrity": "sha1-5QNHYR1+aQlDIIu9r+vLwvuGbUY=",
+  "_location": "/react-bootstrap-table/asap",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "asap@2.0.6",
+    "name": "asap",
+    "escapedName": "asap",
+    "rawSpec": "2.0.6",
+    "saveSpec": null,
+    "fetchSpec": "2.0.6"
+  },
+  "_requiredBy": [
+    "/react-bootstrap-table/promise"
+  ],
+  "_resolved": "https://registry.npmjs.org/asap/-/asap-2.0.6.tgz",
+  "_spec": "2.0.6",
+  "_where": "C:\\Users\\deranjer\\GoglandProjects\\torrent-project\\torrent-project",
+  "browser": {
+    "./asap": "./browser-asap.js",
+    "./asap.js": "./browser-asap.js",
+    "./raw": "./browser-raw.js",
+    "./raw.js": "./browser-raw.js",
+    "./test/domain.js": "./test/browser-domain.js"
+  },
+  "bugs": {
+    "url": "https://github.com/kriskowal/asap/issues"
+  },
+  "description": "High-priority task queue for Node.js and browsers",
+  "devDependencies": {
+    "benchmark": "^1.0.0",
+    "events": "^1.0.1",
+    "jshint": "^2.5.1",
+    "knox": "^0.8.10",
+    "mr": "^2.0.5",
+    "opener": "^1.3.0",
+    "q": "^2.0.3",
+    "q-io": "^2.0.3",
+    "saucelabs": "^0.1.1",
+    "wd": "^0.2.21",
+    "weak-map": "^1.0.5"
+  },
+  "files": [
+    "raw.js",
+    "asap.js",
+    "browser-raw.js",
+    "browser-asap.js"
+  ],
+  "homepage": "https://github.com/kriskowal/asap#readme",
+  "keywords": [
+    "event",
+    "task",
+    "queue"
+  ],
+  "license": "MIT",
+  "main": "./asap.js",
+  "name": "asap",
+  "react-native": {
+    "domain": false
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kriskowal/asap.git"
+  },
+  "scripts": {
+    "benchmarks": "node benchmarks",
+    "lint": "jshint raw.js asap.js browser-raw.js browser-asap.js $(find scripts -name '*.js' | grep -v gauntlet)",
+    "test": "npm run lint && npm run test-node",
+    "test-browser": "node scripts/publish-bundle.js test/asap-test.js | xargs opener",
+    "test-node": "node test/asap-test.js",
+    "test-publish": "node scripts/publish-bundle.js test/asap-test.js | pbcopy",
+    "test-saucelabs": "node scripts/saucelabs.js test/asap-test.js scripts/saucelabs-spot-configurations.json",
+    "test-saucelabs-all": "node scripts/saucelabs.js test/asap-test.js scripts/saucelabs-all-configurations.json",
+    "test-saucelabs-worker": "node scripts/saucelabs-worker-test.js scripts/saucelabs-spot-configurations.json",
+    "test-saucelabs-worker-all": "node scripts/saucelabs-worker-test.js scripts/saucelabs-all-configurations.json",
+    "test-travis": "npm run lint && npm run test-node && npm run test-saucelabs && npm run test-saucelabs-worker"
+  },
+  "version": "2.0.6"
+}

torrent-project/node_modules/react-bootstrap-table/node_modules/asap/raw.js

@@ -0,0 +1,101 @@
+"use strict";
+
+var domain; // The domain module is executed on demand
+var hasSetImmediate = typeof setImmediate === "function";
+
+// Use the fastest means possible to execute a task in its own turn, with
+// priority over other events including network IO events in Node.js.
+//
+// An exception thrown by a task will permanently interrupt the processing of
+// subsequent tasks. The higher level `asap` function ensures that if an
+// exception is thrown by a task, that the task queue will continue flushing as
+// soon as possible, but if you use `rawAsap` directly, you are responsible to
+// either ensure that no exceptions are thrown from your task, or to manually
+// call `rawAsap.requestFlush` if an exception is thrown.
+module.exports = rawAsap;
+function rawAsap(task) {
+    if (!queue.length) {
+        requestFlush();
+        flushing = true;
+    }
+    // Avoids a function call
+    queue[queue.length] = task;
+}
+
+var queue = [];
+// Once a flush has been requested, no further calls to `requestFlush` are
+// necessary until the next `flush` completes.
+var flushing = false;
+// The position of the next task to execute in the task queue. This is
+// preserved between calls to `flush` so that it can be resumed if
+// a task throws an exception.
+var index = 0;
+// If a task schedules additional tasks recursively, the task queue can grow
+// unbounded. To prevent memory excaustion, the task queue will periodically
+// truncate already-completed tasks.
+var capacity = 1024;
+
+// The flush function processes all tasks that have been scheduled with
+// `rawAsap` unless and until one of those tasks throws an exception.
+// If a task throws an exception, `flush` ensures that its state will remain
+// consistent and will resume where it left off when called again.
+// However, `flush` does not make any arrangements to be called again if an
+// exception is thrown.
+function flush() {
+    while (index < queue.length) {
+        var currentIndex = index;
+        // Advance the index before calling the task. This ensures that we will
+        // begin flushing on the next task the task throws an error.
+        index = index + 1;
+        queue[currentIndex].call();
+        // Prevent leaking memory for long chains of recursive calls to `asap`.
+        // If we call `asap` within tasks scheduled by `asap`, the queue will
+        // grow, but to avoid an O(n) walk for every task we execute, we don't
+        // shift tasks off the queue after they have been executed.
+        // Instead, we periodically shift 1024 tasks off the queue.
+        if (index > capacity) {
+            // Manually shift all values starting at the index back to the
+            // beginning of the queue.
+            for (var scan = 0, newLength = queue.length - index; scan < newLength; scan++) {
+                queue[scan] = queue[scan + index];
+            }
+            queue.length -= index;
+            index = 0;
+        }
+    }
+    queue.length = 0;
+    index = 0;
+    flushing = false;
+}
+
+rawAsap.requestFlush = requestFlush;
+function requestFlush() {
+    // Ensure flushing is not bound to any domain.
+    // It is not sufficient to exit the domain, because domains exist on a stack.
+    // To execute code outside of any domain, the following dance is necessary.
+    var parentDomain = process.domain;
+    if (parentDomain) {
+        if (!domain) {
+            // Lazy execute the domain module.
+            // Only employed if the user elects to use domains.
+            domain = require("domain");
+        }
+        domain.active = process.domain = null;
+    }
+
+    // `setImmediate` is slower that `process.nextTick`, but `process.nextTick`
+    // cannot handle recursion.
+    // `requestFlush` will only be called recursively from `asap.js`, to resume
+    // flushing after an error is thrown into a domain.
+    // Conveniently, `setImmediate` was introduced in the same version
+    // `process.nextTick` started throwing recursion errors.
+    if (flushing && hasSetImmediate) {
+        setImmediate(flush);
+    } else {
+        process.nextTick(flush);
+    }
+
+    if (parentDomain) {
+        domain.active = process.domain = parentDomain;
+    }
+}

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/.npmignore

@@ -0,0 +1,2 @@
+scripts
+node_modules

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/README.md

@@ -0,0 +1,2 @@
+# babel-runtime
+

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js.js

@@ -0,0 +1,4 @@
+module.exports = {
+  "default": require("core-js/library"),
+  __esModule: true
+};

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/array/concat.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/array/concat"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/array/copy-within.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/array/copy-within"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/array/entries.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/array/entries"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/array/every.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/array/every"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/array/fill.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/array/fill"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/array/filter.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/array/filter"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/array/find-index.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/array/find-index"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/array/find.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/array/find"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/array/for-each.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/array/for-each"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/array/from.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/array/from"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/array/includes.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/array/includes"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/array/index-of.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/array/index-of"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/array/join.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/array/join"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/array/keys.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/array/keys"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/array/last-index-of.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/array/last-index-of"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/array/map.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/array/map"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/array/of.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/array/of"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/array/pop.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/array/pop"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/array/push.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/array/push"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/array/reduce-right.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/array/reduce-right"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/array/reduce.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/array/reduce"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/array/reverse.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/array/reverse"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/array/shift.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/array/shift"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/array/slice.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/array/slice"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/array/some.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/array/some"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/array/sort.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/array/sort"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/array/splice.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/array/splice"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/array/unshift.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/array/unshift"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/array/values.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/array/values"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/asap.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/asap"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/clear-immediate.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/clear-immediate"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/error/is-error.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/error/is-error"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/get-iterator.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/get-iterator"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/is-iterable.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/is-iterable"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/json/stringify.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/json/stringify"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/map.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/map"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/math/acosh.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/math/acosh"), __esModule: true };

torrent-project/node_modules/react-bootstrap-table/node_modules/babel-runtime/core-js/math/asinh.js

@@ -0,0 +1 @@
+module.exports = { "default": require("core-js/library/fn/math/asinh"), __esModule: true };