@trendmicro/react-paginations/lib/index.js

/*! react-paginations v0.5.9 | (c) 2017 Trend Micro Inc. | MIT | https://github.com/trendmicro-frontend/react-paginations */
module.exports =
/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// identity function for calling harmony imports with the correct context
/******/ 	__webpack_require__.i = function(value) { return value; };
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, {
/******/ 				configurable: false,
/******/ 				enumerable: true,
/******/ 				get: getter
/******/ 			});
/******/ 		}
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 4);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports) {

module.exports = require("prop-types");

/***/ }),
/* 1 */
/***/ (function(module, exports) {

module.exports = require("react");

/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {

"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 _class, _temp2; /* eslimt react/no-set-state: 0 */


var _reactAnchor = __webpack_require__(6);

var _reactAnchor2 = _interopRequireDefault(_reactAnchor);

var _classnames = __webpack_require__(7);

var _classnames2 = _interopRequireDefault(_classnames);

var _propTypes = __webpack_require__(0);

var _propTypes2 = _interopRequireDefault(_propTypes);

var _react = __webpack_require__(1);

var _react2 = _interopRequireDefault(_react);

var _AutosizeInput = __webpack_require__(3);

var _AutosizeInput2 = _interopRequireDefault(_AutosizeInput);

var _index = __webpack_require__(5);

var _index2 = _interopRequireDefault(_index);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function _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; }

// Normalize the value by bringing it within the range.
// If value is greater than max, max will be returned.
// If value is less than min, min will be returned.
// Otherwise, value is returned unaltered. Both ends of this range are inclusive.
var limit = function limit(value, min, max) {
    return Math.max(min, Math.min(max, value));
};

var TablePagination = (_temp2 = _class = function (_Component) {
    _inherits(TablePagination, _Component);

    function TablePagination() {
        var _ref;

        var _temp, _this, _ret;

        _classCallCheck(this, TablePagination);

        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
            args[_key] = arguments[_key];
        }

        return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = TablePagination.__proto__ || Object.getPrototypeOf(TablePagination)).call.apply(_ref, [this].concat(args))), _this), _this.state = {
            shouldOpenDropdownMenu: false,
            page: _this.props.page
        }, _this.actions = {
            toggleDropdownMenu: function toggleDropdownMenu() {
                _this.setState({ shouldOpenDropdownMenu: !_this.state.shouldOpenDropdownMenu });
            },
            closeDropdownMenu: function closeDropdownMenu() {
                _this.setState({ shouldOpenDropdownMenu: false });
            },
            changePage: function changePage(options) {
                var totalRecords = _this.props.totalRecords;

                var _options = _extends({}, options),
                    _options$page = _options.page,
                    page = _options$page === undefined ? _this.props.page : _options$page,
                    _options$pageLength = _options.pageLength,
                    pageLength = _options$pageLength === undefined ? _this.props.pageLength : _options$pageLength;

                var pageMin = 1;
                var pageMax = Math.max(Math.ceil(totalRecords / pageLength), 1);
                _this.props.onPageChange({
                    page: limit(page, pageMin, pageMax),
                    pageLength: pageLength
                });
            }
        }, _temp), _possibleConstructorReturn(_this, _ret);
    }

    _createClass(TablePagination, [{
        key: 'componentWillReceiveProps',
        value: function componentWillReceiveProps(nextProps) {
            if (nextProps.page !== this.state.page) {
                this.setState({ page: Number(nextProps.page) });
            }
        }
    }, {
        key: 'render',
        value: function render() {
            var _this2 = this;

            var _props = this.props,
                type = _props.type,
                _props$totalRecords = _props.totalRecords,
                totalRecords = _props$totalRecords === undefined ? 0 : _props$totalRecords,
                pageLengthMenu = _props.pageLengthMenu,
                prevPageRenderer = _props.prevPageRenderer,
                nextPageRenderer = _props.nextPageRenderer,
                pageRecordsRenderer = _props.pageRecordsRenderer,
                pageLengthRenderer = _props.pageLengthRenderer,
                className = _props.className,
                props = _objectWithoutProperties(_props, ['type', 'totalRecords', 'pageLengthMenu', 'prevPageRenderer', 'nextPageRenderer', 'pageRecordsRenderer', 'pageLengthRenderer', 'className']);

            var pageLength = this.props.pageLength || pageLengthMenu[0] || 10;
            var totalPages = totalRecords > 0 ? Math.ceil(totalRecords / pageLength) : 1;
            var page = limit(this.props.page, 1, totalPages);
            var from = limit((page - 1) * pageLength + 1, 1, totalRecords);
            var to = limit((page - 1) * pageLength + pageLength, 1, totalRecords);
            var prevPageDisabled = page <= 1;
            var nextPageDisabled = page >= totalPages;

            delete props.pageLength;
            delete props.page;
            delete props.onPageChange;

            return _react2.default.createElement(
                'div',
                _extends({}, props, {
                    className: (0, _classnames2.default)(className, _index2.default.tablePagination)
                }),
                _react2.default.createElement(
                    'div',
                    { className: _index2.default.tablePaginationBlock },
                    _react2.default.createElement(
                        'div',
                        { className: _index2.default.paginationRecords },
                        pageRecordsRenderer({ totalRecords: totalRecords, from: from, to: to })
                    ),
                    type !== 'minor' && _react2.default.createElement(
                        'div',
                        {
                            className: (0, _classnames2.default)(_index2.default.dropdown, _defineProperty({}, _index2.default.open, this.state.shouldOpenDropdownMenu))
                        },
                        _react2.default.createElement(
                            'button',
                            {
                                type: 'button',
                                className: (0, _classnames2.default)(_index2.default.btn, _index2.default.dropdownToggle),
                                onClick: this.actions.toggleDropdownMenu,
                                onBlur: this.actions.closeDropdownMenu
                            },
                            pageLengthRenderer({ pageLength: pageLength })
                        ),
                        _react2.default.createElement(
                            'ul',
                            { className: _index2.default.dropdownMenu },
                            pageLengthMenu.map(function (val) {
                                return _react2.default.createElement(
                                    'li',
                                    {
                                        key: val,
                                        className: (0, _classnames2.default)(_defineProperty({}, _index2.default.selected, pageLength === val)),
                                        onMouseDown: function onMouseDown() {
                                            _this2.actions.changePage({
                                                page: val !== pageLength ? 1 : page,
                                                pageLength: val
                                            });
                                        }
                                    },
                                    _react2.default.createElement(
                                        _reactAnchor2.default,
                                        null,
                                        val
                                    )
                                );
                            })
                        )
                    ),
                    type !== 'reduced' && type !== 'minor' && _react2.default.createElement(
                        'div',
                        { className: _index2.default.paginationInput },
                        _react2.default.createElement(_AutosizeInput2.default, {
                            value: this.state.page,
                            onChange: function onChange(event) {
                                var page = Number(event.target.value);
                                if (isNaN(page)) {
                                    return;
                                }
                                _this2.setState({ page: limit(page, 1, totalPages) });
                            },
                            onKeyPress: function onKeyPress(event) {
                                if (event.key !== 'Enter') {
                                    return;
                                }

                                var page = _this2.state.page;

                                page = limit(page, 1, totalPages);

                                if (page !== _this2.state.page) {
                                    _this2.setState({ page: page });
                                }

                                _this2.actions.changePage({ page: page });
                            }
                        }),
                        '\xA0 / \xA0',
                        totalPages
                    ),
                    _react2.default.createElement(
                        'div',
                        null,
                        _react2.default.createElement(
                            'ul',
                            { className: _index2.default.pagination },
                            _react2.default.createElement(
                                'li',
                                {
                                    className: (0, _classnames2.default)(_defineProperty({}, _index2.default.disabled, prevPageDisabled))
                                },
                                _react2.default.createElement(
                                    _reactAnchor2.default,
                                    {
                                        disabled: prevPageDisabled,
                                        onClick: function onClick(event) {
                                            var prevPage = page > 1 ? page - 1 : page;

                                            if (prevPage !== _this2.state.page) {
                                                _this2.setState({ page: prevPage });
                                            }

                                            _this2.actions.changePage({ page: prevPage });
                                        }
                                    },
                                    prevPageRenderer()
                                )
                            ),
                            _react2.default.createElement(
                                'li',
                                {
                                    className: (0, _classnames2.default)(_defineProperty({}, _index2.default.disabled, nextPageDisabled))
                                },
                                _react2.default.createElement(
                                    _reactAnchor2.default,
                                    {
                                        disabled: nextPageDisabled,
                                        onClick: function onClick(event) {
                                            var nextPage = page < totalPages ? page + 1 : page;

                                            if (nextPage !== _this2.state.page) {
                                                _this2.setState({ page: nextPage });
                                            }

                                            _this2.actions.changePage({ page: nextPage });
                                        }
                                    },
                                    nextPageRenderer()
                                )
                            )
                        )
                    )
                )
            );
        }
    }]);

    return TablePagination;
}(_react.Component), _class.propTypes = {
    type: _propTypes2.default.oneOf(['full', 'reduced', 'minor']),
    page: _propTypes2.default.number,
    pageLength: _propTypes2.default.number,
    pageLengthMenu: _propTypes2.default.array,
    totalRecords: _propTypes2.default.number,
    onPageChange: _propTypes2.default.func,
    prevPageRenderer: _propTypes2.default.func,
    nextPageRenderer: _propTypes2.default.func,
    pageRecordsRenderer: _propTypes2.default.func,
    pageLengthRenderer: _propTypes2.default.func
}, _class.defaultProps = {
    type: 'full',
    page: 1,
    pageLength: 10,
    pageLengthMenu: [10, 25, 50, 100],
    totalRecords: 0,
    onPageChange: function onPageChange() {},
    prevPageRenderer: function prevPageRenderer() {
        return '‹';
    },
    nextPageRenderer: function nextPageRenderer() {
        return '›';
    },
    pageRecordsRenderer: function pageRecordsRenderer(_ref2) {
        var totalRecords = _ref2.totalRecords,
            from = _ref2.from,
            to = _ref2.to;

        if (totalRecords > 0) {
            return 'Records: ' + from + ' - ' + to + ' / ' + totalRecords;
        }

        return 'Records: ' + totalRecords;
    },
    pageLengthRenderer: function pageLengthRenderer(_ref3) {
        var pageLength = _ref3.pageLength;

        return _react2.default.createElement(
            'span',
            null,
            pageLength + ' per page',
            _react2.default.createElement('i', { className: _index2.default.caret })
        );
    }
}, _temp2);
exports.default = TablePagination;

/***/ }),
/* 3 */
/***/ (function(module, exports, __webpack_require__) {

"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 _class, _temp2; //
// Forked from https://github.com/JedWatson/react-input-autosize
//


var _propTypes = __webpack_require__(0);

var _propTypes2 = _interopRequireDefault(_propTypes);

var _react = __webpack_require__(1);

var _react2 = _interopRequireDefault(_react);

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 sizerStyle = {
    position: 'absolute',
    top: 0,
    left: 0,
    visibility: 'hidden',
    height: 0,
    overflow: 'scroll',
    whiteSpace: 'pre'
};

var AutosizeInput = (_temp2 = _class = function (_Component) {
    _inherits(AutosizeInput, _Component);

    function AutosizeInput() {
        var _ref;

        var _temp, _this, _ret;

        _classCallCheck(this, AutosizeInput);

        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
            args[_key] = arguments[_key];
        }

        return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = AutosizeInput.__proto__ || Object.getPrototypeOf(AutosizeInput)).call.apply(_ref, [this].concat(args))), _this), _this.state = {
            inputWidth: _this.props.minWidth
        }, _this.nodes = {
            input: null,
            sizer: null,
            placeholderSizer: null
        }, _this._isMounted = false, _temp), _possibleConstructorReturn(_this, _ret);
    }

    _createClass(AutosizeInput, [{
        key: 'componentDidMount',
        value: function componentDidMount() {
            this._isMounted = true;
            this.copyInputStyles();
            this.updateInputWidth();
        }
    }, {
        key: 'componentWillUnmount',
        value: function componentWillUnmount() {
            this._isMounted = false;
        }
    }, {
        key: 'componentDidUpdate',
        value: function componentDidUpdate(prevProps, prevState) {
            if (prevState.inputWidth !== this.state.inputWidth) {
                if (typeof this.props.onAutosize === 'function') {
                    this.props.onAutosize(this.state.inputWidth);
                }
            }
            this.updateInputWidth();
        }
    }, {
        key: 'copyInputStyles',
        value: function copyInputStyles() {
            if (!this._isMounted || !window.getComputedStyle) {
                return;
            }

            var inputStyle = window.getComputedStyle(this.nodes.input);
            if (!inputStyle) {
                return;
            }

            var widthNode = this.nodes.sizer;
            widthNode.style.fontSize = inputStyle.fontSize;
            widthNode.style.fontFamily = inputStyle.fontFamily;
            widthNode.style.fontWeight = inputStyle.fontWeight;
            widthNode.style.fontStyle = inputStyle.fontStyle;
            widthNode.style.letterSpacing = inputStyle.letterSpacing;

            if (this.props.placeholder) {
                var placeholderNode = this.nodes.placeholderSizer;
                placeholderNode.style.fontSize = inputStyle.fontSize;
                placeholderNode.style.fontFamily = inputStyle.fontFamily;
                placeholderNode.style.fontWeight = inputStyle.fontWeight;
                placeholderNode.style.fontStyle = inputStyle.fontStyle;
                placeholderNode.style.letterSpacing = inputStyle.letterSpacing;
            }
        }
    }, {
        key: 'updateInputWidth',
        value: function updateInputWidth() {
            if (!this._isMounted || typeof this.nodes.sizer.scrollWidth === 'undefined') {
                return;
            }
            var newInputWidth = void 0;
            if (this.props.placeholder && (!this.props.value || this.props.value && this.props.placeholderIsMinWidth)) {
                newInputWidth = Math.max(this.nodes.sizer.scrollWidth, this.nodes.placeholderSizer.scrollWidth) + 2;
            } else {
                newInputWidth = this.nodes.sizer.scrollWidth + 2;
            }
            if (newInputWidth < this.props.minWidth) {
                newInputWidth = this.props.minWidth;
            }
            if (newInputWidth !== this.state.inputWidth) {
                this.setState({
                    inputWidth: newInputWidth
                });
            }
        }
    }, {
        key: 'getInput',
        value: function getInput() {
            return this.nodes.input;
        }
    }, {
        key: 'focus',
        value: function focus() {
            this.nodes.input.focus();
        }
    }, {
        key: 'blur',
        value: function blur() {
            this.nodes.input.blur();
        }
    }, {
        key: 'select',
        value: function select() {
            this.nodes.input.select();
        }
    }, {
        key: 'render',
        value: function render() {
            var _this2 = this;

            var sizerValue = [this.props.defaultValue, this.props.value, ''].reduce(function (previousValue, currentValue) {
                if (previousValue !== null && previousValue !== undefined) {
                    return previousValue;
                }
                return currentValue;
            });

            var wrapperStyle = this.props.style || {};
            if (!wrapperStyle.display) {
                wrapperStyle.display = 'inline-block';
            }

            var inputStyle = _extends({}, this.props.inputStyle);
            inputStyle.width = this.state.inputWidth + 'px';
            inputStyle.boxSizing = 'content-box';

            var inputProps = _extends({}, this.props);
            inputProps.className = this.props.inputClassName;
            inputProps.style = inputStyle;

            // ensure props meant for `AutosizeInput` don't end up on the `input`
            delete inputProps.inputClassName;
            delete inputProps.inputStyle;
            delete inputProps.minWidth;
            delete inputProps.placeholderIsMinWidth;

            return _react2.default.createElement(
                'div',
                { className: this.props.className, style: wrapperStyle },
                _react2.default.createElement('input', _extends({}, inputProps, {
                    ref: function ref(node) {
                        _this2.nodes.input = node;
                    }
                })),
                _react2.default.createElement(
                    'div',
                    {
                        ref: function ref(node) {
                            _this2.nodes.sizer = node;
                        },
                        style: sizerStyle
                    },
                    sizerValue
                ),
                this.props.placeholder && _react2.default.createElement(
                    'div',
                    {
                        ref: function ref(node) {
                            _this2.nodes.placeholderSizer = node;
                        },
                        style: sizerStyle
                    },
                    this.props.placeholder
                )
            );
        }
    }]);

    return AutosizeInput;
}(_react.Component), _class.propTypes = {
    // className for the outer element
    className: _propTypes2.default.string,

    // default field value
    defaultValue: _propTypes2.default.any,

    // className for the input element
    inputClassName: _propTypes2.default.string,

    // css style for the input element
    inputStyle: _propTypes2.default.object,

    // minimum width for input element
    minWidth: _propTypes2.default.oneOfType([_propTypes2.default.number, _propTypes2.default.string]),

    // onAutosize handler: function(newWidth) {}
    onAutosize: _propTypes2.default.func,

    // onChange handler: function(newValue) {}
    onChange: _propTypes2.default.func,

    // placeholder text
    placeholder: _propTypes2.default.string,

    // don't collapse size to less than the placeholder
    placeholderIsMinWidth: _propTypes2.default.bool,

    // css styles fro the outer element
    style: _propTypes2.default.object,

    // field value
    value: _propTypes2.default.any
}, _class.defaultProps = {
    minWidth: 1
}, _temp2);
exports.default = AutosizeInput;

/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.TablePagination = undefined;

var _TablePagination2 = __webpack_require__(2);

var _TablePagination3 = _interopRequireDefault(_TablePagination2);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

exports.TablePagination = _TablePagination3.default;

/***/ }),
/* 5 */
/***/ (function(module, exports) {

// removed by extract-text-webpack-plugin
module.exports = {"pagination":"paginations---pagination---2Rb5b","fa":"paginations---fa---2RjFS","active":"paginations---active---2-a32","disabled":"paginations---disabled---eCY9b","table-pagination":"paginations---table-pagination---41TU-","tablePagination":"paginations---table-pagination---41TU-","pull-right":"paginations---pull-right---2juGH","pullRight":"paginations---pull-right---2juGH","table-pagination-block":"paginations---table-pagination-block---Cx6IH","tablePaginationBlock":"paginations---table-pagination-block---Cx6IH","pagination-records":"paginations---pagination-records---YOUAz","paginationRecords":"paginations---pagination-records---YOUAz","dropdown":"paginations---dropdown---1yvIZ","btn":"paginations---btn---2jZHN","caret":"paginations---caret---3CkEt","dropdown-menu":"paginations---dropdown-menu---1fkH0","dropdownMenu":"paginations---dropdown-menu---1fkH0","pagination-input":"paginations---pagination-input---2C8oD","paginationInput":"paginations---pagination-input---2C8oD","open":"paginations---open---1ju75","selected":"paginations---selected---1EK3y"};

/***/ }),
/* 6 */
/***/ (function(module, exports) {

module.exports = require("@trendmicro/react-anchor");

/***/ }),
/* 7 */
/***/ (function(module, exports) {

module.exports = require("classnames");

/***/ })
/******/ ]);
//# sourceMappingURL=index.js.map