@penggy/element-ui 2.4.11

package/lib/table.js

@@ -0,0 +1,3941 @@
+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;
+/******/
+/******/ 	// 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 = "/dist/";
+/******/
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(__webpack_require__.s = 159);
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ 0:
+/***/ (function(module, exports) {
+
+/* globals __VUE_SSR_CONTEXT__ */
+
+// IMPORTANT: Do NOT use ES2015 features in this file.
+// This module is a runtime utility for cleaner component module output and will
+// be included in the final webpack user bundle.
+
+module.exports = function normalizeComponent (
+  rawScriptExports,
+  compiledTemplate,
+  functionalTemplate,
+  injectStyles,
+  scopeId,
+  moduleIdentifier /* server only */
+) {
+  var esModule
+  var scriptExports = rawScriptExports = rawScriptExports || {}
+
+  // ES6 modules interop
+  var type = typeof rawScriptExports.default
+  if (type === 'object' || type === 'function') {
+    esModule = rawScriptExports
+    scriptExports = rawScriptExports.default
+  }
+
+  // Vue.extend constructor export interop
+  var options = typeof scriptExports === 'function'
+    ? scriptExports.options
+    : scriptExports
+
+  // render functions
+  if (compiledTemplate) {
+    options.render = compiledTemplate.render
+    options.staticRenderFns = compiledTemplate.staticRenderFns
+    options._compiled = true
+  }
+
+  // functional template
+  if (functionalTemplate) {
+    options.functional = true
+  }
+
+  // scopedId
+  if (scopeId) {
+    options._scopeId = scopeId
+  }
+
+  var hook
+  if (moduleIdentifier) { // server build
+    hook = function (context) {
+      // 2.3 injection
+      context =
+        context || // cached call
+        (this.$vnode && this.$vnode.ssrContext) || // stateful
+        (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional
+      // 2.2 with runInNewContext: true
+      if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
+        context = __VUE_SSR_CONTEXT__
+      }
+      // inject component styles
+      if (injectStyles) {
+        injectStyles.call(this, context)
+      }
+      // register component module identifier for async chunk inferrence
+      if (context && context._registeredComponents) {
+        context._registeredComponents.add(moduleIdentifier)
+      }
+    }
+    // used by ssr in case component is cached and beforeCreate
+    // never gets called
+    options._ssrRegister = hook
+  } else if (injectStyles) {
+    hook = injectStyles
+  }
+
+  if (hook) {
+    var functional = options.functional
+    var existing = functional
+      ? options.render
+      : options.beforeCreate
+
+    if (!functional) {
+      // inject component registration as beforeCreate hook
+      options.beforeCreate = existing
+        ? [].concat(existing, hook)
+        : [hook]
+    } else {
+      // for template-only hot-reload because in that case the render fn doesn't
+      // go through the normalizer
+      options._injectStyles = hook
+      // register for functioal component in vue file
+      options.render = function renderWithStyleInjection (h, context) {
+        hook.call(context)
+        return existing(h, context)
+      }
+    }
+  }
+
+  return {
+    esModule: esModule,
+    exports: scriptExports,
+    options: options
+  }
+}
+
+
+/***/ }),
+
+/***/ 10:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/utils/clickoutside");
+
+/***/ }),
+
+/***/ 13:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/utils/popup");
+
+/***/ }),
+
+/***/ 14:
+/***/ (function(module, exports) {
+
+module.exports = require("throttle-debounce/debounce");
+
+/***/ }),
+
+/***/ 159:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+exports.__esModule = true;
+
+var _table = __webpack_require__(160);
+
+var _table2 = _interopRequireDefault(_table);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/* istanbul ignore next */
+_table2.default.install = function (Vue) {
+  Vue.component(_table2.default.name, _table2.default);
+};
+
+exports.default = _table2.default;
+
+/***/ }),
+
+/***/ 16:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/checkbox");
+
+/***/ }),
+
+/***/ 160:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_table_vue__ = __webpack_require__(161);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_table_vue___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_table_vue__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_7f7bd8fe_hasScoped_false_preserveWhitespace_false_buble_transforms_node_modules_vue_loader_lib_selector_type_template_index_0_table_vue__ = __webpack_require__(173);
+var normalizeComponent = __webpack_require__(0)
+/* script */
+
+/* template */
+
+/* template functional */
+  var __vue_template_functional__ = false
+/* styles */
+var __vue_styles__ = null
+/* scopeId */
+var __vue_scopeId__ = null
+/* moduleIdentifier (server only) */
+var __vue_module_identifier__ = null
+var Component = normalizeComponent(
+  __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_table_vue___default.a,
+  __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_7f7bd8fe_hasScoped_false_preserveWhitespace_false_buble_transforms_node_modules_vue_loader_lib_selector_type_template_index_0_table_vue__["a" /* default */],
+  __vue_template_functional__,
+  __vue_styles__,
+  __vue_scopeId__,
+  __vue_module_identifier__
+)
+
+/* harmony default export */ __webpack_exports__["default"] = (Component.exports);
+
+
+/***/ }),
+
+/***/ 161:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+exports.__esModule = true;
+
+var _checkbox = __webpack_require__(16);
+
+var _checkbox2 = _interopRequireDefault(_checkbox);
+
+var _debounce = __webpack_require__(14);
+
+var _debounce2 = _interopRequireDefault(_debounce);
+
+var _resizeEvent = __webpack_require__(18);
+
+var _mousewheel = __webpack_require__(162);
+
+var _mousewheel2 = _interopRequireDefault(_mousewheel);
+
+var _locale = __webpack_require__(5);
+
+var _locale2 = _interopRequireDefault(_locale);
+
+var _migrating = __webpack_require__(8);
+
+var _migrating2 = _interopRequireDefault(_migrating);
+
+var _tableStore = __webpack_require__(164);
+
+var _tableStore2 = _interopRequireDefault(_tableStore);
+
+var _tableLayout = __webpack_require__(165);
+
+var _tableLayout2 = _interopRequireDefault(_tableLayout);
+
+var _tableBody = __webpack_require__(166);
+
+var _tableBody2 = _interopRequireDefault(_tableBody);
+
+var _tableHeader = __webpack_require__(167);
+
+var _tableHeader2 = _interopRequireDefault(_tableHeader);
+
+var _tableFooter = __webpack_require__(172);
+
+var _tableFooter2 = _interopRequireDefault(_tableFooter);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var tableIdSeed = 1; //
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+
+exports.default = {
+  name: 'ElTable',
+
+  mixins: [_locale2.default, _migrating2.default],
+
+  directives: {
+    Mousewheel: _mousewheel2.default
+  },
+
+  props: {
+    data: {
+      type: Array,
+      default: function _default() {
+        return [];
+      }
+    },
+
+    size: String,
+
+    width: [String, Number],
+
+    height: [String, Number],
+
+    maxHeight: [String, Number],
+
+    fit: {
+      type: Boolean,
+      default: true
+    },
+
+    stripe: Boolean,
+
+    border: Boolean,
+
+    rowKey: [String, Function],
+
+    context: {},
+
+    showHeader: {
+      type: Boolean,
+      default: true
+    },
+
+    showSummary: Boolean,
+
+    sumText: String,
+
+    summaryMethod: Function,
+
+    rowClassName: [String, Function],
+
+    rowStyle: [Object, Function],
+
+    cellClassName: [String, Function],
+
+    cellStyle: [Object, Function],
+
+    headerRowClassName: [String, Function],
+
+    headerRowStyle: [Object, Function],
+
+    headerCellClassName: [String, Function],
+
+    headerCellStyle: [Object, Function],
+
+    highlightCurrentRow: Boolean,
+
+    currentRowKey: [String, Number],
+
+    emptyText: String,
+
+    expandRowKeys: Array,
+
+    defaultExpandAll: Boolean,
+
+    defaultSort: Object,
+
+    tooltipEffect: String,
+
+    spanMethod: Function,
+
+    selectOnIndeterminate: {
+      type: Boolean,
+      default: true
+    }
+  },
+
+  components: {
+    TableHeader: _tableHeader2.default,
+    TableFooter: _tableFooter2.default,
+    TableBody: _tableBody2.default,
+    ElCheckbox: _checkbox2.default
+  },
+
+  methods: {
+    getMigratingConfig: function getMigratingConfig() {
+      return {
+        events: {
+          expand: 'expand is renamed to expand-change'
+        }
+      };
+    },
+    setCurrentRow: function setCurrentRow(row) {
+      this.store.commit('setCurrentRow', row);
+    },
+    toggleRowSelection: function toggleRowSelection(row, selected) {
+      this.store.toggleRowSelection(row, selected);
+      this.store.updateAllSelected();
+    },
+    toggleRowExpansion: function toggleRowExpansion(row, expanded) {
+      this.store.toggleRowExpansion(row, expanded);
+    },
+    clearSelection: function clearSelection() {
+      this.store.clearSelection();
+    },
+    clearFilter: function clearFilter(columnKeys) {
+      this.store.clearFilter(columnKeys);
+    },
+    clearSort: function clearSort() {
+      this.store.clearSort();
+    },
+    handleMouseLeave: function handleMouseLeave() {
+      this.store.commit('setHoverRow', null);
+      if (this.hoverState) this.hoverState = null;
+    },
+    updateScrollY: function updateScrollY() {
+      this.layout.updateScrollY();
+      this.layout.updateColumnsWidth();
+    },
+    handleFixedMousewheel: function handleFixedMousewheel(event, data) {
+      var bodyWrapper = this.bodyWrapper;
+      if (Math.abs(data.spinY) > 0) {
+        var currentScrollTop = bodyWrapper.scrollTop;
+        if (data.pixelY < 0 && currentScrollTop !== 0) {
+          event.preventDefault();
+        }
+        if (data.pixelY > 0 && bodyWrapper.scrollHeight - bodyWrapper.clientHeight > currentScrollTop) {
+          event.preventDefault();
+        }
+        bodyWrapper.scrollTop += Math.ceil(data.pixelY / 5);
+      } else {
+        bodyWrapper.scrollLeft += Math.ceil(data.pixelX / 5);
+      }
+    },
+    handleHeaderFooterMousewheel: function handleHeaderFooterMousewheel(event, data) {
+      var pixelX = data.pixelX,
+          pixelY = data.pixelY;
+
+      if (Math.abs(pixelX) >= Math.abs(pixelY)) {
+        event.preventDefault();
+        this.bodyWrapper.scrollLeft += data.pixelX / 5;
+      }
+    },
+    bindEvents: function bindEvents() {
+      var _$refs = this.$refs,
+          headerWrapper = _$refs.headerWrapper,
+          footerWrapper = _$refs.footerWrapper;
+
+      var refs = this.$refs;
+      var self = this;
+
+      this.bodyWrapper.addEventListener('scroll', function () {
+        if (headerWrapper) headerWrapper.scrollLeft = this.scrollLeft;
+        if (footerWrapper) footerWrapper.scrollLeft = this.scrollLeft;
+        if (refs.fixedBodyWrapper) refs.fixedBodyWrapper.scrollTop = this.scrollTop;
+        if (refs.rightFixedBodyWrapper) refs.rightFixedBodyWrapper.scrollTop = this.scrollTop;
+        var maxScrollLeftPosition = this.scrollWidth - this.offsetWidth - 1;
+        var scrollLeft = this.scrollLeft;
+        if (scrollLeft >= maxScrollLeftPosition) {
+          self.scrollPosition = 'right';
+        } else if (scrollLeft === 0) {
+          self.scrollPosition = 'left';
+        } else {
+          self.scrollPosition = 'middle';
+        }
+      });
+
+      if (this.fit) {
+        (0, _resizeEvent.addResizeListener)(this.$el, this.resizeListener);
+      }
+    },
+    resizeListener: function resizeListener() {
+      if (!this.$ready) return;
+      var shouldUpdateLayout = false;
+      var el = this.$el;
+      var _resizeState = this.resizeState,
+          oldWidth = _resizeState.width,
+          oldHeight = _resizeState.height;
+
+
+      var width = el.offsetWidth;
+      if (oldWidth !== width) {
+        shouldUpdateLayout = true;
+      }
+
+      var height = el.offsetHeight;
+      if ((this.height || this.shouldUpdateHeight) && oldHeight !== height) {
+        shouldUpdateLayout = true;
+      }
+
+      if (shouldUpdateLayout) {
+        this.resizeState.width = width;
+        this.resizeState.height = height;
+        this.doLayout();
+      }
+    },
+    doLayout: function doLayout() {
+      this.layout.updateColumnsWidth();
+      if (this.shouldUpdateHeight) {
+        this.layout.updateElsHeight();
+      }
+    },
+    sort: function sort(prop, order) {
+      this.store.commit('sort', { prop: prop, order: order });
+    },
+    toggleAllSelection: function toggleAllSelection() {
+      this.store.commit('toggleAllSelection');
+    }
+  },
+
+  created: function created() {
+    var _this = this;
+
+    this.tableId = 'el-table_' + tableIdSeed++;
+    this.debouncedUpdateLayout = (0, _debounce2.default)(50, function () {
+      return _this.doLayout();
+    });
+  },
+
+
+  computed: {
+    tableSize: function tableSize() {
+      return this.size || (this.$ELEMENT || {}).size;
+    },
+    bodyWrapper: function bodyWrapper() {
+      return this.$refs.bodyWrapper;
+    },
+    shouldUpdateHeight: function shouldUpdateHeight() {
+      return this.height || this.maxHeight || this.fixedColumns.length > 0 || this.rightFixedColumns.length > 0;
+    },
+    selection: function selection() {
+      return this.store.states.selection;
+    },
+    columns: function columns() {
+      return this.store.states.columns;
+    },
+    tableData: function tableData() {
+      return this.store.states.data;
+    },
+    fixedColumns: function fixedColumns() {
+      return this.store.states.fixedColumns;
+    },
+    rightFixedColumns: function rightFixedColumns() {
+      return this.store.states.rightFixedColumns;
+    },
+    bodyWidth: function bodyWidth() {
+      var _layout = this.layout,
+          bodyWidth = _layout.bodyWidth,
+          scrollY = _layout.scrollY,
+          gutterWidth = _layout.gutterWidth;
+
+      return bodyWidth ? bodyWidth - (scrollY ? gutterWidth : 0) + 'px' : '';
+    },
+    bodyHeight: function bodyHeight() {
+      if (this.height) {
+        return {
+          height: this.layout.bodyHeight ? this.layout.bodyHeight + 'px' : ''
+        };
+      } else if (this.maxHeight) {
+        return {
+          'max-height': (this.showHeader ? this.maxHeight - this.layout.headerHeight - this.layout.footerHeight : this.maxHeight - this.layout.footerHeight) + 'px'
+        };
+      }
+      return {};
+    },
+    fixedBodyHeight: function fixedBodyHeight() {
+      if (this.height) {
+        return {
+          height: this.layout.fixedBodyHeight ? this.layout.fixedBodyHeight + 'px' : ''
+        };
+      } else if (this.maxHeight) {
+        var maxHeight = this.layout.scrollX ? this.maxHeight - this.layout.gutterWidth : this.maxHeight;
+
+        if (this.showHeader) {
+          maxHeight -= this.layout.headerHeight;
+        }
+
+        maxHeight -= this.layout.footerHeight;
+
+        return {
+          'max-height': maxHeight + 'px'
+        };
+      }
+
+      return {};
+    },
+    fixedHeight: function fixedHeight() {
+      if (this.maxHeight) {
+        if (this.showSummary) {
+          return {
+            bottom: 0
+          };
+        }
+        return {
+          bottom: this.layout.scrollX && this.data.length ? this.layout.gutterWidth + 'px' : ''
+        };
+      } else {
+        if (this.showSummary) {
+          return {
+            height: this.layout.tableHeight ? this.layout.tableHeight + 'px' : ''
+          };
+        }
+        return {
+          height: this.layout.viewportHeight ? this.layout.viewportHeight + 'px' : ''
+        };
+      }
+    }
+  },
+
+  watch: {
+    height: {
+      immediate: true,
+      handler: function handler(value) {
+        this.layout.setHeight(value);
+      }
+    },
+
+    maxHeight: {
+      immediate: true,
+      handler: function handler(value) {
+        this.layout.setMaxHeight(value);
+      }
+    },
+
+    currentRowKey: function currentRowKey(newVal) {
+      this.store.setCurrentRowKey(newVal);
+    },
+
+
+    data: {
+      immediate: true,
+      handler: function handler(value) {
+        var _this2 = this;
+
+        this.store.commit('setData', value);
+        if (this.$ready) {
+          this.$nextTick(function () {
+            _this2.doLayout();
+          });
+        }
+      }
+    },
+
+    expandRowKeys: {
+      immediate: true,
+      handler: function handler(newVal) {
+        if (newVal) {
+          this.store.setExpandRowKeys(newVal);
+        }
+      }
+    }
+  },
+
+  destroyed: function destroyed() {
+    if (this.resizeListener) (0, _resizeEvent.removeResizeListener)(this.$el, this.resizeListener);
+  },
+  mounted: function mounted() {
+    var _this3 = this;
+
+    this.bindEvents();
+    this.store.updateColumns();
+    this.doLayout();
+
+    this.resizeState = {
+      width: this.$el.offsetWidth,
+      height: this.$el.offsetHeight
+    };
+
+    // init filters
+    this.store.states.columns.forEach(function (column) {
+      if (column.filteredValue && column.filteredValue.length) {
+        _this3.store.commit('filterChange', {
+          column: column,
+          values: column.filteredValue,
+          silent: true
+        });
+      }
+    });
+
+    this.$ready = true;
+  },
+  data: function data() {
+    var store = new _tableStore2.default(this, {
+      rowKey: this.rowKey,
+      defaultExpandAll: this.defaultExpandAll,
+      selectOnIndeterminate: this.selectOnIndeterminate
+    });
+    var layout = new _tableLayout2.default({
+      store: store,
+      table: this,
+      fit: this.fit,
+      showHeader: this.showHeader
+    });
+    return {
+      layout: layout,
+      store: store,
+      isHidden: false,
+      renderExpanded: null,
+      resizeProxyVisible: false,
+      resizeState: {
+        width: null,
+        height: null
+      },
+      // 是否拥有多级表头
+      isGroup: false,
+      scrollPosition: 'left'
+    };
+  }
+};
+
+/***/ }),
+
+/***/ 162:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+exports.__esModule = true;
+
+var _normalizeWheel = __webpack_require__(163);
+
+var _normalizeWheel2 = _interopRequireDefault(_normalizeWheel);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var isFirefox = typeof navigator !== 'undefined' && navigator.userAgent.toLowerCase().indexOf('firefox') > -1;
+
+var mousewheel = function mousewheel(element, callback) {
+  if (element && element.addEventListener) {
+    element.addEventListener(isFirefox ? 'DOMMouseScroll' : 'mousewheel', function (event) {
+      var normalized = (0, _normalizeWheel2.default)(event);
+      callback && callback.apply(this, [event, normalized]);
+    });
+  }
+};
+
+exports.default = {
+  bind: function bind(el, binding) {
+    mousewheel(el, binding.value);
+  }
+};
+
+/***/ }),
+
+/***/ 163:
+/***/ (function(module, exports) {
+
+module.exports = require("normalize-wheel");
+
+/***/ }),
+
+/***/ 164:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+exports.__esModule = true;
+
+var _vue = __webpack_require__(4);
+
+var _vue2 = _interopRequireDefault(_vue);
+
+var _debounce = __webpack_require__(14);
+
+var _debounce2 = _interopRequireDefault(_debounce);
+
+var _merge = __webpack_require__(9);
+
+var _merge2 = _interopRequireDefault(_merge);
+
+var _dom = __webpack_require__(3);
+
+var _util = __webpack_require__(48);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var sortData = function sortData(data, states) {
+  var sortingColumn = states.sortingColumn;
+  if (!sortingColumn || typeof sortingColumn.sortable === 'string') {
+    return data;
+  }
+  return (0, _util.orderBy)(data, states.sortProp, states.sortOrder, sortingColumn.sortMethod, sortingColumn.sortBy);
+};
+
+var getKeysMap = function getKeysMap(array, rowKey) {
+  var arrayMap = {};
+  (array || []).forEach(function (row, index) {
+    arrayMap[(0, _util.getRowIdentity)(row, rowKey)] = { row: row, index: index };
+  });
+  return arrayMap;
+};
+
+var toggleRowSelection = function toggleRowSelection(states, row, selected) {
+  var changed = false;
+  var selection = states.selection;
+  var index = selection.indexOf(row);
+  if (typeof selected === 'undefined') {
+    if (index === -1) {
+      selection.push(row);
+      changed = true;
+    } else {
+      selection.splice(index, 1);
+      changed = true;
+    }
+  } else {
+    if (selected && index === -1) {
+      selection.push(row);
+      changed = true;
+    } else if (!selected && index > -1) {
+      selection.splice(index, 1);
+      changed = true;
+    }
+  }
+
+  return changed;
+};
+
+var toggleRowExpansion = function toggleRowExpansion(states, row, expanded) {
+  var changed = false;
+  var expandRows = states.expandRows;
+  if (typeof expanded !== 'undefined') {
+    var index = expandRows.indexOf(row);
+    if (expanded) {
+      if (index === -1) {
+        expandRows.push(row);
+        changed = true;
+      }
+    } else {
+      if (index !== -1) {
+        expandRows.splice(index, 1);
+        changed = true;
+      }
+    }
+  } else {
+    var _index = expandRows.indexOf(row);
+    if (_index === -1) {
+      expandRows.push(row);
+      changed = true;
+    } else {
+      expandRows.splice(_index, 1);
+      changed = true;
+    }
+  }
+
+  return changed;
+};
+
+var TableStore = function TableStore(table) {
+  var initialState = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+  if (!table) {
+    throw new Error('Table is required.');
+  }
+  this.table = table;
+
+  this.states = {
+    rowKey: null,
+    _columns: [],
+    originColumns: [],
+    columns: [],
+    fixedColumns: [],
+    rightFixedColumns: [],
+    leafColumns: [],
+    fixedLeafColumns: [],
+    rightFixedLeafColumns: [],
+    leafColumnsLength: 0,
+    fixedLeafColumnsLength: 0,
+    rightFixedLeafColumnsLength: 0,
+    isComplex: false,
+    filteredData: null,
+    data: null,
+    sortingColumn: null,
+    sortProp: null,
+    sortOrder: null,
+    isAllSelected: false,
+    selection: [],
+    reserveSelection: false,
+    selectable: null,
+    currentRow: null,
+    hoverRow: null,
+    filters: {},
+    expandRows: [],
+    defaultExpandAll: false,
+    selectOnIndeterminate: false
+  };
+
+  for (var prop in initialState) {
+    if (initialState.hasOwnProperty(prop) && this.states.hasOwnProperty(prop)) {
+      this.states[prop] = initialState[prop];
+    }
+  }
+};
+
+TableStore.prototype.mutations = {
+  setData: function setData(states, data) {
+    var _this = this;
+
+    var dataInstanceChanged = states._data !== data;
+    states._data = data;
+
+    Object.keys(states.filters).forEach(function (columnId) {
+      var values = states.filters[columnId];
+      if (!values || values.length === 0) return;
+      var column = (0, _util.getColumnById)(_this.states, columnId);
+      if (column && column.filterMethod) {
+        data = data.filter(function (row) {
+          return values.some(function (value) {
+            return column.filterMethod.call(null, value, row, column);
+          });
+        });
+      }
+    });
+
+    states.filteredData = data;
+    states.data = sortData(data || [], states);
+
+    this.updateCurrentRow();
+
+    var rowKey = states.rowKey;
+
+    if (!states.reserveSelection) {
+      if (dataInstanceChanged) {
+        this.clearSelection();
+      } else {
+        this.cleanSelection();
+      }
+      this.updateAllSelected();
+    } else {
+      if (rowKey) {
+        (function () {
+          var selection = states.selection;
+          var selectedMap = getKeysMap(selection, rowKey);
+
+          states.data.forEach(function (row) {
+            var rowId = (0, _util.getRowIdentity)(row, rowKey);
+            var rowInfo = selectedMap[rowId];
+            if (rowInfo) {
+              selection[rowInfo.index] = row;
+            }
+          });
+
+          _this.updateAllSelected();
+        })();
+      } else {
+        console.warn('WARN: rowKey is required when reserve-selection is enabled.');
+      }
+    }
+
+    var defaultExpandAll = states.defaultExpandAll;
+    if (defaultExpandAll) {
+      this.states.expandRows = (states.data || []).slice(0);
+    } else if (rowKey) {
+      // update expandRows to new rows according to rowKey
+      var ids = getKeysMap(this.states.expandRows, rowKey);
+      var expandRows = [];
+      for (var _iterator = states.data, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+        var _ref;
+
+        if (_isArray) {
+          if (_i >= _iterator.length) break;
+          _ref = _iterator[_i++];
+        } else {
+          _i = _iterator.next();
+          if (_i.done) break;
+          _ref = _i.value;
+        }
+
+        var row = _ref;
+
+        var rowId = (0, _util.getRowIdentity)(row, rowKey);
+        if (ids[rowId]) {
+          expandRows.push(row);
+        }
+      }
+      this.states.expandRows = expandRows;
+    } else {
+      // clear the old rows
+      this.states.expandRows = [];
+    }
+
+    _vue2.default.nextTick(function () {
+      return _this.table.updateScrollY();
+    });
+  },
+  changeSortCondition: function changeSortCondition(states, options) {
+    var _this2 = this;
+
+    states.data = sortData(states.filteredData || states._data || [], states);
+
+    var _table = this.table,
+        $el = _table.$el,
+        highlightCurrentRow = _table.highlightCurrentRow;
+
+    if ($el && highlightCurrentRow) {
+      var data = states.data;
+      var tr = $el.querySelector('tbody').children;
+      var rows = [].filter.call(tr, function (row) {
+        return (0, _dom.hasClass)(row, 'el-table__row');
+      });
+      var row = rows[data.indexOf(states.currentRow)];
+
+      [].forEach.call(rows, function (row) {
+        return (0, _dom.removeClass)(row, 'current-row');
+      });
+      (0, _dom.addClass)(row, 'current-row');
+    }
+
+    if (!options || !options.silent) {
+      this.table.$emit('sort-change', {
+        column: this.states.sortingColumn,
+        prop: this.states.sortProp,
+        order: this.states.sortOrder
+      });
+    }
+
+    _vue2.default.nextTick(function () {
+      return _this2.table.updateScrollY();
+    });
+  },
+  sort: function sort(states, options) {
+    var _this3 = this;
+
+    var prop = options.prop,
+        order = options.order;
+
+    if (prop) {
+      states.sortProp = prop;
+      states.sortOrder = order || 'ascending';
+      _vue2.default.nextTick(function () {
+        for (var i = 0, length = states.columns.length; i < length; i++) {
+          var column = states.columns[i];
+          if (column.property === states.sortProp) {
+            column.order = states.sortOrder;
+            states.sortingColumn = column;
+            break;
+          }
+        }
+
+        if (states.sortingColumn) {
+          _this3.commit('changeSortCondition');
+        }
+      });
+    }
+  },
+  filterChange: function filterChange(states, options) {
+    var _this4 = this;
+
+    var column = options.column,
+        values = options.values,
+        silent = options.silent,
+        multi = options.multi;
+
+    if (values && !Array.isArray(values)) {
+      values = [values];
+    }
+    var filters = {};
+
+    if (multi) {
+      column.forEach(function (col) {
+        states.filters[col.id] = values;
+        filters[col.columnKey || col.id] = values;
+      });
+    } else {
+      var prop = column.property;
+
+      if (prop) {
+        states.filters[column.id] = values;
+        filters[column.columnKey || column.id] = values;
+      }
+    }
+
+    var data = states._data;
+
+    Object.keys(states.filters).forEach(function (columnId) {
+      var values = states.filters[columnId];
+      if (!values || values.length === 0) return;
+      var column = (0, _util.getColumnById)(_this4.states, columnId);
+      if (column && column.filterMethod) {
+        data = data.filter(function (row) {
+          return values.some(function (value) {
+            return column.filterMethod.call(null, value, row, column);
+          });
+        });
+      }
+    });
+
+    states.filteredData = data;
+    states.data = sortData(data, states);
+
+    if (!silent) {
+      this.table.$emit('filter-change', filters);
+    }
+
+    _vue2.default.nextTick(function () {
+      return _this4.table.updateScrollY();
+    });
+  },
+  insertColumn: function insertColumn(states, column, index, parent) {
+    var array = states._columns;
+    if (parent) {
+      array = parent.children;
+      if (!array) array = parent.children = [];
+    }
+
+    if (typeof index !== 'undefined') {
+      array.splice(index, 0, column);
+    } else {
+      array.push(column);
+    }
+
+    if (column.type === 'selection') {
+      states.selectable = column.selectable;
+      states.reserveSelection = column.reserveSelection;
+    }
+
+    if (this.table.$ready) {
+      this.updateColumns(); // hack for dynamics insert column
+      this.scheduleLayout();
+    }
+  },
+  removeColumn: function removeColumn(states, column, parent) {
+    var array = states._columns;
+    if (parent) {
+      array = parent.children;
+      if (!array) array = parent.children = [];
+    }
+    if (array) {
+      array.splice(array.indexOf(column), 1);
+    }
+
+    if (this.table.$ready) {
+      this.updateColumns(); // hack for dynamics remove column
+      this.scheduleLayout();
+    }
+  },
+  setHoverRow: function setHoverRow(states, row) {
+    states.hoverRow = row;
+  },
+  setCurrentRow: function setCurrentRow(states, row) {
+    var oldCurrentRow = states.currentRow;
+    states.currentRow = row;
+
+    if (oldCurrentRow !== row) {
+      this.table.$emit('current-change', row, oldCurrentRow);
+    }
+  },
+  rowSelectedChanged: function rowSelectedChanged(states, row) {
+    var changed = toggleRowSelection(states, row);
+    var selection = states.selection;
+
+    if (changed) {
+      var table = this.table;
+      table.$emit('selection-change', selection ? selection.slice() : []);
+      table.$emit('select', selection, row);
+    }
+
+    this.updateAllSelected();
+  },
+
+
+  toggleAllSelection: (0, _debounce2.default)(10, function (states) {
+    var data = states.data || [];
+    if (data.length === 0) return;
+    var selection = this.states.selection;
+    // when only some rows are selected (but not all), select or deselect all of them
+    // depending on the value of selectOnIndeterminate
+    var value = states.selectOnIndeterminate ? !states.isAllSelected : !(states.isAllSelected || selection.length);
+    var selectionChanged = false;
+
+    data.forEach(function (item, index) {
+      if (states.selectable) {
+        if (states.selectable.call(null, item, index) && toggleRowSelection(states, item, value)) {
+          selectionChanged = true;
+        }
+      } else {
+        if (toggleRowSelection(states, item, value)) {
+          selectionChanged = true;
+        }
+      }
+    });
+
+    var table = this.table;
+    if (selectionChanged) {
+      table.$emit('selection-change', selection ? selection.slice() : []);
+    }
+    table.$emit('select-all', selection);
+    states.isAllSelected = value;
+  })
+};
+
+var doFlattenColumns = function doFlattenColumns(columns) {
+  var result = [];
+  columns.forEach(function (column) {
+    if (column.children) {
+      result.push.apply(result, doFlattenColumns(column.children));
+    } else {
+      result.push(column);
+    }
+  });
+  return result;
+};
+
+TableStore.prototype.updateColumns = function () {
+  var states = this.states;
+  var _columns = states._columns || [];
+  states.fixedColumns = _columns.filter(function (column) {
+    return column.fixed === true || column.fixed === 'left';
+  });
+  states.rightFixedColumns = _columns.filter(function (column) {
+    return column.fixed === 'right';
+  });
+
+  if (states.fixedColumns.length > 0 && _columns[0] && _columns[0].type === 'selection' && !_columns[0].fixed) {
+    _columns[0].fixed = true;
+    states.fixedColumns.unshift(_columns[0]);
+  }
+
+  var notFixedColumns = _columns.filter(function (column) {
+    return !column.fixed;
+  });
+  states.originColumns = [].concat(states.fixedColumns).concat(notFixedColumns).concat(states.rightFixedColumns);
+
+  var leafColumns = doFlattenColumns(notFixedColumns);
+  var fixedLeafColumns = doFlattenColumns(states.fixedColumns);
+  var rightFixedLeafColumns = doFlattenColumns(states.rightFixedColumns);
+
+  states.leafColumnsLength = leafColumns.length;
+  states.fixedLeafColumnsLength = fixedLeafColumns.length;
+  states.rightFixedLeafColumnsLength = rightFixedLeafColumns.length;
+
+  states.columns = [].concat(fixedLeafColumns).concat(leafColumns).concat(rightFixedLeafColumns);
+  states.isComplex = states.fixedColumns.length > 0 || states.rightFixedColumns.length > 0;
+};
+
+TableStore.prototype.isSelected = function (row) {
+  return (this.states.selection || []).indexOf(row) > -1;
+};
+
+TableStore.prototype.clearSelection = function () {
+  var states = this.states;
+  states.isAllSelected = false;
+  var oldSelection = states.selection;
+  if (states.selection.length) {
+    states.selection = [];
+  }
+  if (oldSelection.length > 0) {
+    this.table.$emit('selection-change', states.selection ? states.selection.slice() : []);
+  }
+};
+
+TableStore.prototype.setExpandRowKeys = function (rowKeys) {
+  var expandRows = [];
+  var data = this.states.data;
+  var rowKey = this.states.rowKey;
+  if (!rowKey) throw new Error('[Table] prop row-key should not be empty.');
+  var keysMap = getKeysMap(data, rowKey);
+  rowKeys.forEach(function (key) {
+    var info = keysMap[key];
+    if (info) {
+      expandRows.push(info.row);
+    }
+  });
+
+  this.states.expandRows = expandRows;
+};
+
+TableStore.prototype.toggleRowSelection = function (row, selected) {
+  var changed = toggleRowSelection(this.states, row, selected);
+  if (changed) {
+    this.table.$emit('selection-change', this.states.selection ? this.states.selection.slice() : []);
+  }
+};
+
+TableStore.prototype.toggleRowExpansion = function (row, expanded) {
+  var changed = toggleRowExpansion(this.states, row, expanded);
+  if (changed) {
+    this.table.$emit('expand-change', row, this.states.expandRows);
+    this.scheduleLayout();
+  }
+};
+
+TableStore.prototype.isRowExpanded = function (row) {
+  var _states = this.states,
+      _states$expandRows = _states.expandRows,
+      expandRows = _states$expandRows === undefined ? [] : _states$expandRows,
+      rowKey = _states.rowKey;
+
+  if (rowKey) {
+    var expandMap = getKeysMap(expandRows, rowKey);
+    return !!expandMap[(0, _util.getRowIdentity)(row, rowKey)];
+  }
+  return expandRows.indexOf(row) !== -1;
+};
+
+TableStore.prototype.cleanSelection = function () {
+  var selection = this.states.selection || [];
+  var data = this.states.data;
+  var rowKey = this.states.rowKey;
+  var deleted = void 0;
+  if (rowKey) {
+    deleted = [];
+    var selectedMap = getKeysMap(selection, rowKey);
+    var dataMap = getKeysMap(data, rowKey);
+    for (var key in selectedMap) {
+      if (selectedMap.hasOwnProperty(key) && !dataMap[key]) {
+        deleted.push(selectedMap[key].row);
+      }
+    }
+  } else {
+    deleted = selection.filter(function (item) {
+      return data.indexOf(item) === -1;
+    });
+  }
+
+  deleted.forEach(function (deletedItem) {
+    selection.splice(selection.indexOf(deletedItem), 1);
+  });
+
+  if (deleted.length) {
+    this.table.$emit('selection-change', selection ? selection.slice() : []);
+  }
+};
+
+TableStore.prototype.clearFilter = function (columnKeys) {
+  var _this5 = this;
+
+  var states = this.states;
+  var _table$$refs = this.table.$refs,
+      tableHeader = _table$$refs.tableHeader,
+      fixedTableHeader = _table$$refs.fixedTableHeader,
+      rightFixedTableHeader = _table$$refs.rightFixedTableHeader;
+
+  var panels = {};
+
+  if (tableHeader) panels = (0, _merge2.default)(panels, tableHeader.filterPanels);
+  if (fixedTableHeader) panels = (0, _merge2.default)(panels, fixedTableHeader.filterPanels);
+  if (rightFixedTableHeader) panels = (0, _merge2.default)(panels, rightFixedTableHeader.filterPanels);
+
+  var keys = Object.keys(panels);
+  if (!keys.length) return;
+
+  if (typeof columnKeys === 'string') {
+    columnKeys = [columnKeys];
+  }
+  if (Array.isArray(columnKeys)) {
+    (function () {
+      var columns = columnKeys.map(function (key) {
+        return (0, _util.getColumnByKey)(states, key);
+      });
+      keys.forEach(function (key) {
+        var column = columns.find(function (col) {
+          return col.id === key;
+        });
+        if (column) {
+          panels[key].filteredValue = [];
+        }
+      });
+      _this5.commit('filterChange', {
+        column: columns,
+        value: [],
+        silent: true,
+        multi: true
+      });
+    })();
+  } else {
+    keys.forEach(function (key) {
+      panels[key].filteredValue = [];
+    });
+
+    states.filters = {};
+
+    this.commit('filterChange', {
+      column: {},
+      values: [],
+      silent: true
+    });
+  }
+};
+
+TableStore.prototype.clearSort = function () {
+  var states = this.states;
+  if (!states.sortingColumn) return;
+  states.sortingColumn.order = null;
+  states.sortProp = null;
+  states.sortOrder = null;
+
+  this.commit('changeSortCondition', {
+    silent: true
+  });
+};
+
+TableStore.prototype.updateAllSelected = function () {
+  var states = this.states;
+  var selection = states.selection,
+      rowKey = states.rowKey,
+      selectable = states.selectable,
+      data = states.data;
+
+  if (!data || data.length === 0) {
+    states.isAllSelected = false;
+    return;
+  }
+
+  var selectedMap = void 0;
+  if (rowKey) {
+    selectedMap = getKeysMap(states.selection, rowKey);
+  }
+
+  var isSelected = function isSelected(row) {
+    if (selectedMap) {
+      return !!selectedMap[(0, _util.getRowIdentity)(row, rowKey)];
+    } else {
+      return selection.indexOf(row) !== -1;
+    }
+  };
+
+  var isAllSelected = true;
+  var selectedCount = 0;
+  for (var i = 0, j = data.length; i < j; i++) {
+    var item = data[i];
+    var isRowSelectable = selectable && selectable.call(null, item, i);
+    if (!isSelected(item)) {
+      if (!selectable || isRowSelectable) {
+        isAllSelected = false;
+        break;
+      }
+    } else {
+      selectedCount++;
+    }
+  }
+
+  if (selectedCount === 0) isAllSelected = false;
+
+  states.isAllSelected = isAllSelected;
+};
+
+TableStore.prototype.scheduleLayout = function (updateColumns) {
+  if (updateColumns) {
+    this.updateColumns();
+  }
+  this.table.debouncedUpdateLayout();
+};
+
+TableStore.prototype.setCurrentRowKey = function (key) {
+  var states = this.states;
+  var rowKey = states.rowKey;
+  if (!rowKey) throw new Error('[Table] row-key should not be empty.');
+  var data = states.data || [];
+  var keysMap = getKeysMap(data, rowKey);
+  var info = keysMap[key];
+  states.currentRow = info ? info.row : null;
+};
+
+TableStore.prototype.updateCurrentRow = function () {
+  var states = this.states;
+  var table = this.table;
+  var data = states.data || [];
+  var oldCurrentRow = states.currentRow;
+
+  if (data.indexOf(oldCurrentRow) === -1) {
+    if (states.rowKey && oldCurrentRow) {
+      var newCurrentRow = null;
+      for (var i = 0; i < data.length; i++) {
+        var item = data[i];
+        if (item && item[states.rowKey] === oldCurrentRow[states.rowKey]) {
+          newCurrentRow = item;
+          break;
+        }
+      }
+      if (newCurrentRow) {
+        states.currentRow = newCurrentRow;
+        return;
+      }
+    }
+    states.currentRow = null;
+
+    if (states.currentRow !== oldCurrentRow) {
+      table.$emit('current-change', null, oldCurrentRow);
+    }
+  }
+};
+
+TableStore.prototype.commit = function (name) {
+  var mutations = this.mutations;
+  if (mutations[name]) {
+    for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+
+    mutations[name].apply(this, [this.states].concat(args));
+  } else {
+    throw new Error('Action not found: ' + name);
+  }
+};
+
+exports.default = TableStore;
+
+/***/ }),
+
+/***/ 165:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+exports.__esModule = true;
+
+var _scrollbarWidth = __webpack_require__(38);
+
+var _scrollbarWidth2 = _interopRequireDefault(_scrollbarWidth);
+
+var _vue = __webpack_require__(4);
+
+var _vue2 = _interopRequireDefault(_vue);
+
+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 TableLayout = function () {
+  function TableLayout(options) {
+    _classCallCheck(this, TableLayout);
+
+    this.observers = [];
+    this.table = null;
+    this.store = null;
+    this.columns = null;
+    this.fit = true;
+    this.showHeader = true;
+
+    this.height = null;
+    this.scrollX = false;
+    this.scrollY = false;
+    this.bodyWidth = null;
+    this.fixedWidth = null;
+    this.rightFixedWidth = null;
+    this.tableHeight = null;
+    this.headerHeight = 44; // Table Header Height
+    this.appendHeight = 0; // Append Slot Height
+    this.footerHeight = 44; // Table Footer Height
+    this.viewportHeight = null; // Table Height - Scroll Bar Height
+    this.bodyHeight = null; // Table Height - Table Header Height
+    this.fixedBodyHeight = null; // Table Height - Table Header Height - Scroll Bar Height
+    this.gutterWidth = (0, _scrollbarWidth2.default)();
+
+    for (var name in options) {
+      if (options.hasOwnProperty(name)) {
+        this[name] = options[name];
+      }
+    }
+
+    if (!this.table) {
+      throw new Error('table is required for Table Layout');
+    }
+    if (!this.store) {
+      throw new Error('store is required for Table Layout');
+    }
+  }
+
+  TableLayout.prototype.updateScrollY = function updateScrollY() {
+    var height = this.height;
+    if (typeof height !== 'string' && typeof height !== 'number') return;
+    var bodyWrapper = this.table.bodyWrapper;
+    if (this.table.$el && bodyWrapper) {
+      var body = bodyWrapper.querySelector('.el-table__body');
+      this.scrollY = body.offsetHeight > this.bodyHeight;
+    }
+  };
+
+  TableLayout.prototype.setHeight = function setHeight(value) {
+    var _this = this;
+
+    var prop = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'height';
+
+    if (_vue2.default.prototype.$isServer) return;
+    var el = this.table.$el;
+    if (typeof value === 'string' && /^\d+$/.test(value)) {
+      value = Number(value);
+    }
+    this.height = value;
+
+    if (!el && (value || value === 0)) return _vue2.default.nextTick(function () {
+      return _this.setHeight(value, prop);
+    });
+
+    if (typeof value === 'number') {
+      el.style[prop] = value + 'px';
+
+      this.updateElsHeight();
+    } else if (typeof value === 'string') {
+      el.style[prop] = value;
+      this.updateElsHeight();
+    }
+  };
+
+  TableLayout.prototype.setMaxHeight = function setMaxHeight(value) {
+    return this.setHeight(value, 'max-height');
+  };
+
+  TableLayout.prototype.updateElsHeight = function updateElsHeight() {
+    var _this2 = this;
+
+    if (!this.table.$ready) return _vue2.default.nextTick(function () {
+      return _this2.updateElsHeight();
+    });
+    var _table$$refs = this.table.$refs,
+        headerWrapper = _table$$refs.headerWrapper,
+        appendWrapper = _table$$refs.appendWrapper,
+        footerWrapper = _table$$refs.footerWrapper;
+
+    this.appendHeight = appendWrapper ? appendWrapper.offsetHeight : 0;
+
+    if (this.showHeader && !headerWrapper) return;
+    var headerHeight = this.headerHeight = !this.showHeader ? 0 : headerWrapper.offsetHeight;
+    if (this.showHeader && headerWrapper.offsetWidth > 0 && (this.table.columns || []).length > 0 && headerHeight < 2) {
+      return _vue2.default.nextTick(function () {
+        return _this2.updateElsHeight();
+      });
+    }
+    var tableHeight = this.tableHeight = this.table.$el.clientHeight;
+    if (this.height !== null && (!isNaN(this.height) || typeof this.height === 'string')) {
+      var footerHeight = this.footerHeight = footerWrapper ? footerWrapper.offsetHeight : 0;
+      this.bodyHeight = tableHeight - headerHeight - footerHeight + (footerWrapper ? 1 : 0);
+    }
+    this.fixedBodyHeight = this.scrollX ? this.bodyHeight - this.gutterWidth : this.bodyHeight;
+
+    var noData = !this.table.data || this.table.data.length === 0;
+    this.viewportHeight = this.scrollX ? tableHeight - (noData ? 0 : this.gutterWidth) : tableHeight;
+
+    this.updateScrollY();
+    this.notifyObservers('scrollable');
+  };
+
+  TableLayout.prototype.getFlattenColumns = function getFlattenColumns() {
+    var flattenColumns = [];
+    var columns = this.table.columns;
+    columns.forEach(function (column) {
+      if (column.isColumnGroup) {
+        flattenColumns.push.apply(flattenColumns, column.columns);
+      } else {
+        flattenColumns.push(column);
+      }
+    });
+
+    return flattenColumns;
+  };
+
+  TableLayout.prototype.updateColumnsWidth = function updateColumnsWidth() {
+    if (_vue2.default.prototype.$isServer) return;
+    var fit = this.fit;
+    var bodyWidth = this.table.$el.clientWidth;
+    var bodyMinWidth = 0;
+
+    var flattenColumns = this.getFlattenColumns();
+    var flexColumns = flattenColumns.filter(function (column) {
+      return typeof column.width !== 'number';
+    });
+
+    flattenColumns.forEach(function (column) {
+      // Clean those columns whose width changed from flex to unflex
+      if (typeof column.width === 'number' && column.realWidth) column.realWidth = null;
+    });
+
+    if (flexColumns.length > 0 && fit) {
+      flattenColumns.forEach(function (column) {
+        bodyMinWidth += column.width || column.minWidth || 80;
+      });
+
+      var scrollYWidth = this.scrollY ? this.gutterWidth : 0;
+
+      if (bodyMinWidth <= bodyWidth - scrollYWidth) {
+        // DON'T HAVE SCROLL BAR
+        this.scrollX = false;
+
+        var totalFlexWidth = bodyWidth - scrollYWidth - bodyMinWidth;
+
+        if (flexColumns.length === 1) {
+          flexColumns[0].realWidth = (flexColumns[0].minWidth || 80) + totalFlexWidth;
+        } else {
+          (function () {
+            var allColumnsWidth = flexColumns.reduce(function (prev, column) {
+              return prev + (column.minWidth || 80);
+            }, 0);
+            var flexWidthPerPixel = totalFlexWidth / allColumnsWidth;
+            var noneFirstWidth = 0;
+
+            flexColumns.forEach(function (column, index) {
+              if (index === 0) return;
+              var flexWidth = Math.floor((column.minWidth || 80) * flexWidthPerPixel);
+              noneFirstWidth += flexWidth;
+              column.realWidth = (column.minWidth || 80) + flexWidth;
+            });
+
+            flexColumns[0].realWidth = (flexColumns[0].minWidth || 80) + totalFlexWidth - noneFirstWidth;
+          })();
+        }
+      } else {
+        // HAVE HORIZONTAL SCROLL BAR
+        this.scrollX = true;
+        flexColumns.forEach(function (column) {
+          column.realWidth = column.minWidth;
+        });
+      }
+
+      this.bodyWidth = Math.max(bodyMinWidth, bodyWidth);
+      this.table.resizeState.width = this.bodyWidth;
+    } else {
+      flattenColumns.forEach(function (column) {
+        if (!column.width && !column.minWidth) {
+          column.realWidth = 80;
+        } else {
+          column.realWidth = column.width || column.minWidth;
+        }
+
+        bodyMinWidth += column.realWidth;
+      });
+      this.scrollX = bodyMinWidth > bodyWidth;
+
+      this.bodyWidth = bodyMinWidth;
+    }
+
+    var fixedColumns = this.store.states.fixedColumns;
+
+    if (fixedColumns.length > 0) {
+      var fixedWidth = 0;
+      fixedColumns.forEach(function (column) {
+        fixedWidth += column.realWidth || column.width;
+      });
+
+      this.fixedWidth = fixedWidth;
+    }
+
+    var rightFixedColumns = this.store.states.rightFixedColumns;
+    if (rightFixedColumns.length > 0) {
+      var rightFixedWidth = 0;
+      rightFixedColumns.forEach(function (column) {
+        rightFixedWidth += column.realWidth || column.width;
+      });
+
+      this.rightFixedWidth = rightFixedWidth;
+    }
+
+    this.notifyObservers('columns');
+  };
+
+  TableLayout.prototype.addObserver = function addObserver(observer) {
+    this.observers.push(observer);
+  };
+
+  TableLayout.prototype.removeObserver = function removeObserver(observer) {
+    var index = this.observers.indexOf(observer);
+    if (index !== -1) {
+      this.observers.splice(index, 1);
+    }
+  };
+
+  TableLayout.prototype.notifyObservers = function notifyObservers(event) {
+    var _this3 = this;
+
+    var observers = this.observers;
+    observers.forEach(function (observer) {
+      switch (event) {
+        case 'columns':
+          observer.onColumnsChange(_this3);
+          break;
+        case 'scrollable':
+          observer.onScrollableChange(_this3);
+          break;
+        default:
+          throw new Error('Table Layout don\'t have event ' + event + '.');
+      }
+    });
+  };
+
+  return TableLayout;
+}();
+
+exports.default = TableLayout;
+
+/***/ }),
+
+/***/ 166:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+exports.__esModule = 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 _util = __webpack_require__(48);
+
+var _dom = __webpack_require__(3);
+
+var _checkbox = __webpack_require__(16);
+
+var _checkbox2 = _interopRequireDefault(_checkbox);
+
+var _tooltip = __webpack_require__(22);
+
+var _tooltip2 = _interopRequireDefault(_tooltip);
+
+var _debounce = __webpack_require__(14);
+
+var _debounce2 = _interopRequireDefault(_debounce);
+
+var _layoutObserver = __webpack_require__(39);
+
+var _layoutObserver2 = _interopRequireDefault(_layoutObserver);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = {
+  name: 'ElTableBody',
+
+  mixins: [_layoutObserver2.default],
+
+  components: {
+    ElCheckbox: _checkbox2.default,
+    ElTooltip: _tooltip2.default
+  },
+
+  props: {
+    store: {
+      required: true
+    },
+    stripe: Boolean,
+    context: {},
+    rowClassName: [String, Function],
+    rowStyle: [Object, Function],
+    fixed: String,
+    highlight: Boolean
+  },
+
+  render: function render(h) {
+    var _this = this;
+
+    var columnsHidden = this.columns.map(function (column, index) {
+      return _this.isColumnHidden(index);
+    });
+    return h(
+      'table',
+      {
+        'class': 'el-table__body',
+        attrs: { cellspacing: '0',
+          cellpadding: '0',
+          border: '0' }
+      },
+      [h(
+        'colgroup',
+        null,
+        [this._l(this.columns, function (column) {
+          return h(
+            'col',
+            {
+              attrs: { name: column.id }
+            },
+            []
+          );
+        })]
+      ), h(
+        'tbody',
+        null,
+        [this._l(this.data, function (row, $index) {
+          return [h(
+            'tr',
+            {
+              style: _this.rowStyle ? _this.getRowStyle(row, $index) : null,
+              key: _this.table.rowKey ? _this.getKeyOfRow(row, $index) : $index,
+              on: {
+                'dblclick': function dblclick($event) {
+                  return _this.handleDoubleClick($event, row);
+                },
+                'click': function click($event) {
+                  return _this.handleClick($event, row);
+                },
+                'contextmenu': function contextmenu($event) {
+                  return _this.handleContextMenu($event, row);
+                },
+                'mouseenter': function mouseenter(_) {
+                  return _this.handleMouseEnter($index);
+                },
+                'mouseleave': function mouseleave(_) {
+                  return _this.handleMouseLeave();
+                }
+              },
+
+              'class': [_this.getRowClass(row, $index)] },
+            [_this._l(_this.columns, function (column, cellIndex) {
+              var _getSpan = _this.getSpan(row, column, $index, cellIndex),
+                  rowspan = _getSpan.rowspan,
+                  colspan = _getSpan.colspan;
+
+              if (!rowspan || !colspan) {
+                return '';
+              } else {
+                return h(
+                  'td',
+                  {
+                    style: _this.getCellStyle($index, cellIndex, row, column),
+                    'class': _this.getCellClass($index, cellIndex, row, column),
+                    attrs: { rowspan: rowspan,
+                      colspan: colspan
+                    },
+                    on: {
+                      'mouseenter': function mouseenter($event) {
+                        return _this.handleCellMouseEnter($event, row);
+                      },
+                      'mouseleave': _this.handleCellMouseLeave
+                    }
+                  },
+                  [column.renderCell.call(_this._renderProxy, h, {
+                    row: row,
+                    column: column,
+                    $index: $index,
+                    store: _this.store,
+                    _self: _this.context || _this.table.$vnode.context
+                  }, columnsHidden[cellIndex])]
+                );
+              }
+            })]
+          ), _this.store.isRowExpanded(row) ? h(
+            'tr',
+            null,
+            [h(
+              'td',
+              {
+                attrs: { colspan: _this.columns.length },
+                'class': 'el-table__expanded-cell' },
+              [_this.table.renderExpanded ? _this.table.renderExpanded(h, { row: row, $index: $index, store: _this.store }) : '']
+            )]
+          ) : ''];
+        }).concat(h(
+          'el-tooltip',
+          {
+            attrs: { effect: this.table.tooltipEffect, placement: 'top', content: this.tooltipContent },
+            ref: 'tooltip' },
+          []
+        ))]
+      )]
+    );
+  },
+
+
+  watch: {
+    'store.states.hoverRow': function storeStatesHoverRow(newVal, oldVal) {
+      if (!this.store.states.isComplex) return;
+      var el = this.$el;
+      if (!el) return;
+      var tr = el.querySelector('tbody').children;
+      var rows = [].filter.call(tr, function (row) {
+        return (0, _dom.hasClass)(row, 'el-table__row');
+      });
+      var oldRow = rows[oldVal];
+      var newRow = rows[newVal];
+      if (oldRow) {
+        (0, _dom.removeClass)(oldRow, 'hover-row');
+      }
+      if (newRow) {
+        (0, _dom.addClass)(newRow, 'hover-row');
+      }
+    },
+    'store.states.currentRow': function storeStatesCurrentRow(newVal, oldVal) {
+      if (!this.highlight) return;
+      var el = this.$el;
+      if (!el) return;
+      var data = this.store.states.data;
+      var tr = el.querySelector('tbody').children;
+      var rows = [].filter.call(tr, function (row) {
+        return (0, _dom.hasClass)(row, 'el-table__row');
+      });
+      var oldRow = rows[data.indexOf(oldVal)];
+      var newRow = rows[data.indexOf(newVal)];
+      if (oldRow) {
+        (0, _dom.removeClass)(oldRow, 'current-row');
+      } else {
+        [].forEach.call(rows, function (row) {
+          return (0, _dom.removeClass)(row, 'current-row');
+        });
+      }
+      if (newRow) {
+        (0, _dom.addClass)(newRow, 'current-row');
+      }
+    }
+  },
+
+  computed: {
+    table: function table() {
+      return this.$parent;
+    },
+    data: function data() {
+      return this.store.states.data;
+    },
+    columnsCount: function columnsCount() {
+      return this.store.states.columns.length;
+    },
+    leftFixedLeafCount: function leftFixedLeafCount() {
+      return this.store.states.fixedLeafColumnsLength;
+    },
+    rightFixedLeafCount: function rightFixedLeafCount() {
+      return this.store.states.rightFixedLeafColumnsLength;
+    },
+    leftFixedCount: function leftFixedCount() {
+      return this.store.states.fixedColumns.length;
+    },
+    rightFixedCount: function rightFixedCount() {
+      return this.store.states.rightFixedColumns.length;
+    },
+    columns: function columns() {
+      return this.store.states.columns;
+    }
+  },
+
+  data: function data() {
+    return {
+      tooltipContent: ''
+    };
+  },
+  created: function created() {
+    this.activateTooltip = (0, _debounce2.default)(50, function (tooltip) {
+      return tooltip.handleShowPopper();
+    });
+  },
+
+
+  methods: {
+    getKeyOfRow: function getKeyOfRow(row, index) {
+      var rowKey = this.table.rowKey;
+      if (rowKey) {
+        return (0, _util.getRowIdentity)(row, rowKey);
+      }
+      return index;
+    },
+    isColumnHidden: function isColumnHidden(index) {
+      if (this.fixed === true || this.fixed === 'left') {
+        return index >= this.leftFixedLeafCount;
+      } else if (this.fixed === 'right') {
+        return index < this.columnsCount - this.rightFixedLeafCount;
+      } else {
+        return index < this.leftFixedLeafCount || index >= this.columnsCount - this.rightFixedLeafCount;
+      }
+    },
+    getSpan: function getSpan(row, column, rowIndex, columnIndex) {
+      var rowspan = 1;
+      var colspan = 1;
+
+      var fn = this.table.spanMethod;
+      if (typeof fn === 'function') {
+        var result = fn({
+          row: row,
+          column: column,
+          rowIndex: rowIndex,
+          columnIndex: columnIndex
+        });
+
+        if (Array.isArray(result)) {
+          rowspan = result[0];
+          colspan = result[1];
+        } else if ((typeof result === 'undefined' ? 'undefined' : _typeof(result)) === 'object') {
+          rowspan = result.rowspan;
+          colspan = result.colspan;
+        }
+      }
+
+      return {
+        rowspan: rowspan,
+        colspan: colspan
+      };
+    },
+    getRowStyle: function getRowStyle(row, rowIndex) {
+      var rowStyle = this.table.rowStyle;
+      if (typeof rowStyle === 'function') {
+        return rowStyle.call(null, {
+          row: row,
+          rowIndex: rowIndex
+        });
+      }
+      return rowStyle;
+    },
+    getRowClass: function getRowClass(row, rowIndex) {
+      var classes = ['el-table__row'];
+      if (this.table.highlightCurrentRow && row === this.store.states.currentRow) {
+        classes.push('current-row');
+      }
+
+      if (this.stripe && rowIndex % 2 === 1) {
+        classes.push('el-table__row--striped');
+      }
+      var rowClassName = this.table.rowClassName;
+      if (typeof rowClassName === 'string') {
+        classes.push(rowClassName);
+      } else if (typeof rowClassName === 'function') {
+        classes.push(rowClassName.call(null, {
+          row: row,
+          rowIndex: rowIndex
+        }));
+      }
+
+      if (this.store.states.expandRows.indexOf(row) > -1) {
+        classes.push('expanded');
+      }
+
+      return classes.join(' ');
+    },
+    getCellStyle: function getCellStyle(rowIndex, columnIndex, row, column) {
+      var cellStyle = this.table.cellStyle;
+      if (typeof cellStyle === 'function') {
+        return cellStyle.call(null, {
+          rowIndex: rowIndex,
+          columnIndex: columnIndex,
+          row: row,
+          column: column
+        });
+      }
+      return cellStyle;
+    },
+    getCellClass: function getCellClass(rowIndex, columnIndex, row, column) {
+      var classes = [column.id, column.align, column.className];
+
+      if (this.isColumnHidden(columnIndex)) {
+        classes.push('is-hidden');
+      }
+
+      var cellClassName = this.table.cellClassName;
+      if (typeof cellClassName === 'string') {
+        classes.push(cellClassName);
+      } else if (typeof cellClassName === 'function') {
+        classes.push(cellClassName.call(null, {
+          rowIndex: rowIndex,
+          columnIndex: columnIndex,
+          row: row,
+          column: column
+        }));
+      }
+
+      return classes.join(' ');
+    },
+    handleCellMouseEnter: function handleCellMouseEnter(event, row) {
+      var table = this.table;
+      var cell = (0, _util.getCell)(event);
+
+      if (cell) {
+        var column = (0, _util.getColumnByCell)(table, cell);
+        var hoverState = table.hoverState = { cell: cell, column: column, row: row };
+        table.$emit('cell-mouse-enter', hoverState.row, hoverState.column, hoverState.cell, event);
+      }
+
+      // 判断是否text-overflow, 如果是就显示tooltip
+      var cellChild = event.target.querySelector('.cell');
+      if (!((0, _dom.hasClass)(cellChild, 'el-tooltip') && cellChild.childNodes.length)) {
+        return;
+      }
+      // use range width instead of scrollWidth to determine whether the text is overflowing
+      // to address a potential FireFox bug: https://bugzilla.mozilla.org/show_bug.cgi?id=1074543#c3
+      var range = document.createRange();
+      range.setStart(cellChild, 0);
+      range.setEnd(cellChild, cellChild.childNodes.length);
+      var rangeWidth = range.getBoundingClientRect().width;
+      var padding = (parseInt((0, _dom.getStyle)(cellChild, 'paddingLeft'), 10) || 0) + (parseInt((0, _dom.getStyle)(cellChild, 'paddingRight'), 10) || 0);
+      if ((rangeWidth + padding > cellChild.offsetWidth || cellChild.scrollWidth > cellChild.offsetWidth) && this.$refs.tooltip) {
+        var tooltip = this.$refs.tooltip;
+        // TODO 会引起整个 Table 的重新渲染，需要优化
+        this.tooltipContent = cell.innerText || cell.textContent;
+        tooltip.referenceElm = cell;
+        tooltip.$refs.popper && (tooltip.$refs.popper.style.display = 'none');
+        tooltip.doDestroy();
+        tooltip.setExpectedState(true);
+        this.activateTooltip(tooltip);
+      }
+    },
+    handleCellMouseLeave: function handleCellMouseLeave(event) {
+      var tooltip = this.$refs.tooltip;
+      if (tooltip) {
+        tooltip.setExpectedState(false);
+        tooltip.handleClosePopper();
+      }
+      var cell = (0, _util.getCell)(event);
+      if (!cell) return;
+
+      var oldHoverState = this.table.hoverState || {};
+      this.table.$emit('cell-mouse-leave', oldHoverState.row, oldHoverState.column, oldHoverState.cell, event);
+    },
+    handleMouseEnter: function handleMouseEnter(index) {
+      this.store.commit('setHoverRow', index);
+    },
+    handleMouseLeave: function handleMouseLeave() {
+      this.store.commit('setHoverRow', null);
+    },
+    handleContextMenu: function handleContextMenu(event, row) {
+      this.handleEvent(event, row, 'contextmenu');
+    },
+    handleDoubleClick: function handleDoubleClick(event, row) {
+      this.handleEvent(event, row, 'dblclick');
+    },
+    handleClick: function handleClick(event, row) {
+      this.store.commit('setCurrentRow', row);
+      this.handleEvent(event, row, 'click');
+    },
+    handleEvent: function handleEvent(event, row, name) {
+      var table = this.table;
+      var cell = (0, _util.getCell)(event);
+      var column = void 0;
+      if (cell) {
+        column = (0, _util.getColumnByCell)(table, cell);
+        if (column) {
+          table.$emit('cell-' + name, row, column, cell, event);
+        }
+      }
+      table.$emit('row-' + name, row, event, column);
+    },
+    handleExpandClick: function handleExpandClick(row, e) {
+      e.stopPropagation();
+      this.store.toggleRowExpansion(row);
+    }
+  }
+};
+
+/***/ }),
+
+/***/ 167:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+exports.__esModule = true;
+
+var _dom = __webpack_require__(3);
+
+var _checkbox = __webpack_require__(16);
+
+var _checkbox2 = _interopRequireDefault(_checkbox);
+
+var _tag = __webpack_require__(25);
+
+var _tag2 = _interopRequireDefault(_tag);
+
+var _vue = __webpack_require__(4);
+
+var _vue2 = _interopRequireDefault(_vue);
+
+var _filterPanel = __webpack_require__(168);
+
+var _filterPanel2 = _interopRequireDefault(_filterPanel);
+
+var _layoutObserver = __webpack_require__(39);
+
+var _layoutObserver2 = _interopRequireDefault(_layoutObserver);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var getAllColumns = function getAllColumns(columns) {
+  var result = [];
+  columns.forEach(function (column) {
+    if (column.children) {
+      result.push(column);
+      result.push.apply(result, getAllColumns(column.children));
+    } else {
+      result.push(column);
+    }
+  });
+  return result;
+};
+
+var convertToRows = function convertToRows(originColumns) {
+  var maxLevel = 1;
+  var traverse = function traverse(column, parent) {
+    if (parent) {
+      column.level = parent.level + 1;
+      if (maxLevel < column.level) {
+        maxLevel = column.level;
+      }
+    }
+    if (column.children) {
+      var colSpan = 0;
+      column.children.forEach(function (subColumn) {
+        traverse(subColumn, column);
+        colSpan += subColumn.colSpan;
+      });
+      column.colSpan = colSpan;
+    } else {
+      column.colSpan = 1;
+    }
+  };
+
+  originColumns.forEach(function (column) {
+    column.level = 1;
+    traverse(column);
+  });
+
+  var rows = [];
+  for (var i = 0; i < maxLevel; i++) {
+    rows.push([]);
+  }
+
+  var allColumns = getAllColumns(originColumns);
+
+  allColumns.forEach(function (column) {
+    if (!column.children) {
+      column.rowSpan = maxLevel - column.level + 1;
+    } else {
+      column.rowSpan = 1;
+    }
+    rows[column.level - 1].push(column);
+  });
+
+  return rows;
+};
+
+exports.default = {
+  name: 'ElTableHeader',
+
+  mixins: [_layoutObserver2.default],
+
+  render: function render(h) {
+    var _this = this;
+
+    var originColumns = this.store.states.originColumns;
+    var columnRows = convertToRows(originColumns, this.columns);
+    // 是否拥有多级表头
+    var isGroup = columnRows.length > 1;
+    if (isGroup) this.$parent.isGroup = true;
+    return h(
+      'table',
+      {
+        'class': 'el-table__header',
+        attrs: { cellspacing: '0',
+          cellpadding: '0',
+          border: '0' }
+      },
+      [h(
+        'colgroup',
+        null,
+        [this._l(this.columns, function (column) {
+          return h(
+            'col',
+            {
+              attrs: { name: column.id }
+            },
+            []
+          );
+        }), this.hasGutter ? h(
+          'col',
+          {
+            attrs: { name: 'gutter' }
+          },
+          []
+        ) : '']
+      ), h(
+        'thead',
+        { 'class': [{ 'is-group': isGroup, 'has-gutter': this.hasGutter }] },
+        [this._l(columnRows, function (columns, rowIndex) {
+          return h(
+            'tr',
+            {
+              style: _this.getHeaderRowStyle(rowIndex),
+              'class': _this.getHeaderRowClass(rowIndex)
+            },
+            [_this._l(columns, function (column, cellIndex) {
+              return h(
+                'th',
+                {
+                  attrs: {
+                    colspan: column.colSpan,
+                    rowspan: column.rowSpan
+                  },
+                  on: {
+                    'mousemove': function mousemove($event) {
+                      return _this.handleMouseMove($event, column);
+                    },
+                    'mouseout': _this.handleMouseOut,
+                    'mousedown': function mousedown($event) {
+                      return _this.handleMouseDown($event, column);
+                    },
+                    'click': function click($event) {
+                      return _this.handleHeaderClick($event, column);
+                    },
+                    'contextmenu': function contextmenu($event) {
+                      return _this.handleHeaderContextMenu($event, column);
+                    }
+                  },
+
+                  style: _this.getHeaderCellStyle(rowIndex, cellIndex, columns, column),
+                  'class': _this.getHeaderCellClass(rowIndex, cellIndex, columns, column),
+                  key: column.id },
+                [h(
+                  'div',
+                  { 'class': ['cell', column.filteredValue && column.filteredValue.length > 0 ? 'highlight' : '', column.labelClassName] },
+                  [column.renderHeader ? column.renderHeader.call(_this._renderProxy, h, { column: column, $index: cellIndex, store: _this.store, _self: _this.$parent.$vnode.context }) : column.label, column.sortable ? h(
+                    'span',
+                    { 'class': 'caret-wrapper', on: {
+                        'click': function click($event) {
+                          return _this.handleSortClick($event, column);
+                        }
+                      }
+                    },
+                    [h(
+                      'i',
+                      { 'class': 'sort-caret ascending', on: {
+                          'click': function click($event) {
+                            return _this.handleSortClick($event, column, 'ascending');
+                          }
+                        }
+                      },
+                      []
+                    ), h(
+                      'i',
+                      { 'class': 'sort-caret descending', on: {
+                          'click': function click($event) {
+                            return _this.handleSortClick($event, column, 'descending');
+                          }
+                        }
+                      },
+                      []
+                    )]
+                  ) : '', column.filterable ? h(
+                    'span',
+                    { 'class': 'el-table__column-filter-trigger', on: {
+                        'click': function click($event) {
+                          return _this.handleFilterClick($event, column);
+                        }
+                      }
+                    },
+                    [h(
+                      'i',
+                      { 'class': ['el-icon-arrow-down', column.filterOpened ? 'el-icon-arrow-up' : ''] },
+                      []
+                    )]
+                  ) : '']
+                )]
+              );
+            }), _this.hasGutter ? h(
+              'th',
+              { 'class': 'gutter' },
+              []
+            ) : '']
+          );
+        })]
+      )]
+    );
+  },
+
+
+  props: {
+    fixed: String,
+    store: {
+      required: true
+    },
+    border: Boolean,
+    defaultSort: {
+      type: Object,
+      default: function _default() {
+        return {
+          prop: '',
+          order: ''
+        };
+      }
+    }
+  },
+
+  components: {
+    ElCheckbox: _checkbox2.default,
+    ElTag: _tag2.default
+  },
+
+  computed: {
+    table: function table() {
+      return this.$parent;
+    },
+    isAllSelected: function isAllSelected() {
+      return this.store.states.isAllSelected;
+    },
+    columnsCount: function columnsCount() {
+      return this.store.states.columns.length;
+    },
+    leftFixedCount: function leftFixedCount() {
+      return this.store.states.fixedColumns.length;
+    },
+    rightFixedCount: function rightFixedCount() {
+      return this.store.states.rightFixedColumns.length;
+    },
+    leftFixedLeafCount: function leftFixedLeafCount() {
+      return this.store.states.fixedLeafColumnsLength;
+    },
+    rightFixedLeafCount: function rightFixedLeafCount() {
+      return this.store.states.rightFixedLeafColumnsLength;
+    },
+    columns: function columns() {
+      return this.store.states.columns;
+    },
+    hasGutter: function hasGutter() {
+      return !this.fixed && this.tableLayout.gutterWidth;
+    }
+  },
+
+  created: function created() {
+    this.filterPanels = {};
+  },
+  mounted: function mounted() {
+    var _defaultSort = this.defaultSort,
+        prop = _defaultSort.prop,
+        order = _defaultSort.order;
+
+    this.store.commit('sort', { prop: prop, order: order });
+  },
+  beforeDestroy: function beforeDestroy() {
+    var panels = this.filterPanels;
+    for (var prop in panels) {
+      if (panels.hasOwnProperty(prop) && panels[prop]) {
+        panels[prop].$destroy(true);
+      }
+    }
+  },
+
+
+  methods: {
+    isCellHidden: function isCellHidden(index, columns) {
+      var start = 0;
+      for (var i = 0; i < index; i++) {
+        start += columns[i].colSpan;
+      }
+      var after = start + columns[index].colSpan - 1;
+      if (this.fixed === true || this.fixed === 'left') {
+        return after >= this.leftFixedLeafCount;
+      } else if (this.fixed === 'right') {
+        return start < this.columnsCount - this.rightFixedLeafCount;
+      } else {
+        return after < this.leftFixedLeafCount || start >= this.columnsCount - this.rightFixedLeafCount;
+      }
+    },
+    getHeaderRowStyle: function getHeaderRowStyle(rowIndex) {
+      var headerRowStyle = this.table.headerRowStyle;
+      if (typeof headerRowStyle === 'function') {
+        return headerRowStyle.call(null, { rowIndex: rowIndex });
+      }
+      return headerRowStyle;
+    },
+    getHeaderRowClass: function getHeaderRowClass(rowIndex) {
+      var classes = [];
+
+      var headerRowClassName = this.table.headerRowClassName;
+      if (typeof headerRowClassName === 'string') {
+        classes.push(headerRowClassName);
+      } else if (typeof headerRowClassName === 'function') {
+        classes.push(headerRowClassName.call(null, { rowIndex: rowIndex }));
+      }
+
+      return classes.join(' ');
+    },
+    getHeaderCellStyle: function getHeaderCellStyle(rowIndex, columnIndex, row, column) {
+      var headerCellStyle = this.table.headerCellStyle;
+      if (typeof headerCellStyle === 'function') {
+        return headerCellStyle.call(null, {
+          rowIndex: rowIndex,
+          columnIndex: columnIndex,
+          row: row,
+          column: column
+        });
+      }
+      return headerCellStyle;
+    },
+    getHeaderCellClass: function getHeaderCellClass(rowIndex, columnIndex, row, column) {
+      var classes = [column.id, column.order, column.headerAlign, column.className, column.labelClassName];
+
+      if (rowIndex === 0 && this.isCellHidden(columnIndex, row)) {
+        classes.push('is-hidden');
+      }
+
+      if (!column.children) {
+        classes.push('is-leaf');
+      }
+
+      if (column.sortable) {
+        classes.push('is-sortable');
+      }
+
+      var headerCellClassName = this.table.headerCellClassName;
+      if (typeof headerCellClassName === 'string') {
+        classes.push(headerCellClassName);
+      } else if (typeof headerCellClassName === 'function') {
+        classes.push(headerCellClassName.call(null, {
+          rowIndex: rowIndex,
+          columnIndex: columnIndex,
+          row: row,
+          column: column
+        }));
+      }
+
+      return classes.join(' ');
+    },
+    toggleAllSelection: function toggleAllSelection(event) {
+      event.stopPropagation();
+      this.store.commit('toggleAllSelection');
+    },
+    handleFilterClick: function handleFilterClick(event, column) {
+      event.stopPropagation();
+      var target = event.target;
+      var cell = target.tagName === 'TH' ? target : target.parentNode;
+      cell = cell.querySelector('.el-table__column-filter-trigger') || cell;
+      var table = this.$parent;
+
+      var filterPanel = this.filterPanels[column.id];
+
+      if (filterPanel && column.filterOpened) {
+        filterPanel.showPopper = false;
+        return;
+      }
+
+      if (!filterPanel) {
+        filterPanel = new _vue2.default(_filterPanel2.default);
+        this.filterPanels[column.id] = filterPanel;
+        if (column.filterPlacement) {
+          filterPanel.placement = column.filterPlacement;
+        }
+        filterPanel.table = table;
+        filterPanel.cell = cell;
+        filterPanel.column = column;
+        !this.$isServer && filterPanel.$mount(document.createElement('div'));
+      }
+
+      setTimeout(function () {
+        filterPanel.showPopper = true;
+      }, 16);
+    },
+    handleHeaderClick: function handleHeaderClick(event, column) {
+      if (!column.filters && column.sortable) {
+        this.handleSortClick(event, column);
+      } else if (column.filterable && !column.sortable) {
+        this.handleFilterClick(event, column);
+      }
+
+      this.$parent.$emit('header-click', column, event);
+    },
+    handleHeaderContextMenu: function handleHeaderContextMenu(event, column) {
+      this.$parent.$emit('header-contextmenu', column, event);
+    },
+    handleMouseDown: function handleMouseDown(event, column) {
+      var _this2 = this;
+
+      if (this.$isServer) return;
+      if (column.children && column.children.length > 0) return;
+      /* istanbul ignore if */
+      if (this.draggingColumn && this.border) {
+        (function () {
+          _this2.dragging = true;
+
+          _this2.$parent.resizeProxyVisible = true;
+
+          var table = _this2.$parent;
+          var tableEl = table.$el;
+          var tableLeft = tableEl.getBoundingClientRect().left;
+          var columnEl = _this2.$el.querySelector('th.' + column.id);
+          var columnRect = columnEl.getBoundingClientRect();
+          var minLeft = columnRect.left - tableLeft + 30;
+
+          (0, _dom.addClass)(columnEl, 'noclick');
+
+          _this2.dragState = {
+            startMouseLeft: event.clientX,
+            startLeft: columnRect.right - tableLeft,
+            startColumnLeft: columnRect.left - tableLeft,
+            tableLeft: tableLeft
+          };
+
+          var resizeProxy = table.$refs.resizeProxy;
+          resizeProxy.style.left = _this2.dragState.startLeft + 'px';
+
+          document.onselectstart = function () {
+            return false;
+          };
+          document.ondragstart = function () {
+            return false;
+          };
+
+          var handleMouseMove = function handleMouseMove(event) {
+            var deltaLeft = event.clientX - _this2.dragState.startMouseLeft;
+            var proxyLeft = _this2.dragState.startLeft + deltaLeft;
+
+            resizeProxy.style.left = Math.max(minLeft, proxyLeft) + 'px';
+          };
+
+          var handleMouseUp = function handleMouseUp() {
+            if (_this2.dragging) {
+              var _dragState = _this2.dragState,
+                  startColumnLeft = _dragState.startColumnLeft,
+                  startLeft = _dragState.startLeft;
+
+              var finalLeft = parseInt(resizeProxy.style.left, 10);
+              var columnWidth = finalLeft - startColumnLeft;
+              column.width = column.realWidth = columnWidth;
+              table.$emit('header-dragend', column.width, startLeft - startColumnLeft, column, event);
+
+              _this2.store.scheduleLayout();
+
+              document.body.style.cursor = '';
+              _this2.dragging = false;
+              _this2.draggingColumn = null;
+              _this2.dragState = {};
+
+              table.resizeProxyVisible = false;
+            }
+
+            document.removeEventListener('mousemove', handleMouseMove);
+            document.removeEventListener('mouseup', handleMouseUp);
+            document.onselectstart = null;
+            document.ondragstart = null;
+
+            setTimeout(function () {
+              (0, _dom.removeClass)(columnEl, 'noclick');
+            }, 0);
+          };
+
+          document.addEventListener('mousemove', handleMouseMove);
+          document.addEventListener('mouseup', handleMouseUp);
+        })();
+      }
+    },
+    handleMouseMove: function handleMouseMove(event, column) {
+      if (column.children && column.children.length > 0) return;
+      var target = event.target;
+      while (target && target.tagName !== 'TH') {
+        target = target.parentNode;
+      }
+
+      if (!column || !column.resizable) return;
+
+      if (!this.dragging && this.border) {
+        var rect = target.getBoundingClientRect();
+
+        var bodyStyle = document.body.style;
+        if (rect.width > 12 && rect.right - event.pageX < 8) {
+          bodyStyle.cursor = 'col-resize';
+          if ((0, _dom.hasClass)(target, 'is-sortable')) {
+            target.style.cursor = 'col-resize';
+          }
+          this.draggingColumn = column;
+        } else if (!this.dragging) {
+          bodyStyle.cursor = '';
+          if ((0, _dom.hasClass)(target, 'is-sortable')) {
+            target.style.cursor = 'pointer';
+          }
+          this.draggingColumn = null;
+        }
+      }
+    },
+    handleMouseOut: function handleMouseOut() {
+      if (this.$isServer) return;
+      document.body.style.cursor = '';
+    },
+    toggleOrder: function toggleOrder(_ref) {
+      var order = _ref.order,
+          sortOrders = _ref.sortOrders;
+
+      if (order === '') return sortOrders[0];
+      var index = sortOrders.indexOf(order || null);
+      return sortOrders[index > sortOrders.length - 2 ? 0 : index + 1];
+    },
+    handleSortClick: function handleSortClick(event, column, givenOrder) {
+      event.stopPropagation();
+      var order = givenOrder || this.toggleOrder(column);
+
+      var target = event.target;
+      while (target && target.tagName !== 'TH') {
+        target = target.parentNode;
+      }
+
+      if (target && target.tagName === 'TH') {
+        if ((0, _dom.hasClass)(target, 'noclick')) {
+          (0, _dom.removeClass)(target, 'noclick');
+          return;
+        }
+      }
+
+      if (!column.sortable) return;
+
+      var states = this.store.states;
+      var sortProp = states.sortProp;
+      var sortOrder = void 0;
+      var sortingColumn = states.sortingColumn;
+
+      if (sortingColumn !== column || sortingColumn === column && sortingColumn.order === null) {
+        if (sortingColumn) {
+          sortingColumn.order = null;
+        }
+        states.sortingColumn = column;
+        sortProp = column.property;
+      }
+
+      if (!order) {
+        sortOrder = column.order = null;
+        states.sortingColumn = null;
+        sortProp = null;
+      } else {
+        sortOrder = column.order = order;
+      }
+
+      states.sortProp = sortProp;
+      states.sortOrder = sortOrder;
+
+      this.store.commit('changeSortCondition');
+    }
+  },
+
+  data: function data() {
+    return {
+      draggingColumn: null,
+      dragging: false,
+      dragState: {}
+    };
+  }
+};
+
+/***/ }),
+
+/***/ 168:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_filter_panel_vue__ = __webpack_require__(169);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_filter_panel_vue___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_filter_panel_vue__);
+/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_6c30520c_hasScoped_false_preserveWhitespace_false_buble_transforms_node_modules_vue_loader_lib_selector_type_template_index_0_filter_panel_vue__ = __webpack_require__(171);
+var normalizeComponent = __webpack_require__(0)
+/* script */
+
+/* template */
+
+/* template functional */
+  var __vue_template_functional__ = false
+/* styles */
+var __vue_styles__ = null
+/* scopeId */
+var __vue_scopeId__ = null
+/* moduleIdentifier (server only) */
+var __vue_module_identifier__ = null
+var Component = normalizeComponent(
+  __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_filter_panel_vue___default.a,
+  __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_6c30520c_hasScoped_false_preserveWhitespace_false_buble_transforms_node_modules_vue_loader_lib_selector_type_template_index_0_filter_panel_vue__["a" /* default */],
+  __vue_template_functional__,
+  __vue_styles__,
+  __vue_scopeId__,
+  __vue_module_identifier__
+)
+
+/* harmony default export */ __webpack_exports__["default"] = (Component.exports);
+
+
+/***/ }),
+
+/***/ 169:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+exports.__esModule = true;
+
+var _vuePopper = __webpack_require__(7);
+
+var _vuePopper2 = _interopRequireDefault(_vuePopper);
+
+var _popup = __webpack_require__(13);
+
+var _locale = __webpack_require__(5);
+
+var _locale2 = _interopRequireDefault(_locale);
+
+var _clickoutside = __webpack_require__(10);
+
+var _clickoutside2 = _interopRequireDefault(_clickoutside);
+
+var _dropdown = __webpack_require__(170);
+
+var _dropdown2 = _interopRequireDefault(_dropdown);
+
+var _checkbox = __webpack_require__(16);
+
+var _checkbox2 = _interopRequireDefault(_checkbox);
+
+var _checkboxGroup = __webpack_require__(40);
+
+var _checkboxGroup2 = _interopRequireDefault(_checkboxGroup);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = {
+  name: 'ElTableFilterPanel',
+
+  mixins: [_vuePopper2.default, _locale2.default],
+
+  directives: {
+    Clickoutside: _clickoutside2.default
+  },
+
+  components: {
+    ElCheckbox: _checkbox2.default,
+    ElCheckboxGroup: _checkboxGroup2.default
+  },
+
+  props: {
+    placement: {
+      type: String,
+      default: 'bottom-end'
+    }
+  },
+
+  customRender: function customRender(h) {
+    return h(
+      'div',
+      { 'class': 'el-table-filter' },
+      [h(
+        'div',
+        { 'class': 'el-table-filter__content' },
+        []
+      ), h(
+        'div',
+        { 'class': 'el-table-filter__bottom' },
+        [h(
+          'button',
+          {
+            on: {
+              'click': this.handleConfirm
+            }
+          },
+          [this.t('el.table.confirmFilter')]
+        ), h(
+          'button',
+          {
+            on: {
+              'click': this.handleReset
+            }
+          },
+          [this.t('el.table.resetFilter')]
+        )]
+      )]
+    );
+  },
+
+
+  methods: {
+    isActive: function isActive(filter) {
+      return filter.value === this.filterValue;
+    },
+    handleOutsideClick: function handleOutsideClick() {
+      var _this = this;
+
+      setTimeout(function () {
+        _this.showPopper = false;
+      }, 16);
+    },
+    handleConfirm: function handleConfirm() {
+      this.confirmFilter(this.filteredValue);
+      this.handleOutsideClick();
+    },
+    handleReset: function handleReset() {
+      this.filteredValue = [];
+      this.confirmFilter(this.filteredValue);
+      this.handleOutsideClick();
+    },
+    handleSelect: function handleSelect(filterValue) {
+      this.filterValue = filterValue;
+
+      if (typeof filterValue !== 'undefined' && filterValue !== null) {
+        this.confirmFilter(this.filteredValue);
+      } else {
+        this.confirmFilter([]);
+      }
+
+      this.handleOutsideClick();
+    },
+    confirmFilter: function confirmFilter(filteredValue) {
+      this.table.store.commit('filterChange', {
+        column: this.column,
+        values: filteredValue
+      });
+      this.table.store.updateAllSelected();
+    }
+  },
+
+  data: function data() {
+    return {
+      table: null,
+      cell: null,
+      column: null
+    };
+  },
+
+
+  computed: {
+    filters: function filters() {
+      return this.column && this.column.filters;
+    },
+
+
+    filterValue: {
+      get: function get() {
+        return (this.column.filteredValue || [])[0];
+      },
+      set: function set(value) {
+        if (this.filteredValue) {
+          if (typeof value !== 'undefined' && value !== null) {
+            this.filteredValue.splice(0, 1, value);
+          } else {
+            this.filteredValue.splice(0, 1);
+          }
+        }
+      }
+    },
+
+    filteredValue: {
+      get: function get() {
+        if (this.column) {
+          return this.column.filteredValue || [];
+        }
+        return [];
+      },
+      set: function set(value) {
+        if (this.column) {
+          this.column.filteredValue = value;
+        }
+      }
+    },
+
+    multiple: function multiple() {
+      if (this.column) {
+        return this.column.filterMultiple;
+      }
+      return true;
+    }
+  },
+
+  mounted: function mounted() {
+    var _this2 = this;
+
+    this.popperElm = this.$el;
+    this.referenceElm = this.cell;
+    this.table.bodyWrapper.addEventListener('scroll', function () {
+      _this2.updatePopper();
+    });
+
+    this.$watch('showPopper', function (value) {
+      if (_this2.column) _this2.column.filterOpened = value;
+      if (value) {
+        _dropdown2.default.open(_this2);
+      } else {
+        _dropdown2.default.close(_this2);
+      }
+    });
+  },
+
+  watch: {
+    showPopper: function showPopper(val) {
+      if (val === true && parseInt(this.popperJS._popper.style.zIndex, 10) < _popup.PopupManager.zIndex) {
+        this.popperJS._popper.style.zIndex = _popup.PopupManager.nextZIndex();
+      }
+    }
+  }
+}; //
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+
+/***/ }),
+
+/***/ 170:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+exports.__esModule = true;
+
+var _vue = __webpack_require__(4);
+
+var _vue2 = _interopRequireDefault(_vue);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var dropdowns = [];
+
+!_vue2.default.prototype.$isServer && document.addEventListener('click', function (event) {
+  dropdowns.forEach(function (dropdown) {
+    var target = event.target;
+    if (!dropdown || !dropdown.$el) return;
+    if (target === dropdown.$el || dropdown.$el.contains(target)) {
+      return;
+    }
+    dropdown.handleOutsideClick && dropdown.handleOutsideClick(event);
+  });
+});
+
+exports.default = {
+  open: function open(instance) {
+    if (instance) {
+      dropdowns.push(instance);
+    }
+  },
+  close: function close(instance) {
+    var index = dropdowns.indexOf(instance);
+    if (index !== -1) {
+      dropdowns.splice(instance, 1);
+    }
+  }
+};
+
+/***/ }),
+
+/***/ 171:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('transition',{attrs:{"name":"el-zoom-in-top"}},[(_vm.multiple)?_c('div',{directives:[{name:"clickoutside",rawName:"v-clickoutside",value:(_vm.handleOutsideClick),expression:"handleOutsideClick"},{name:"show",rawName:"v-show",value:(_vm.showPopper),expression:"showPopper"}],staticClass:"el-table-filter"},[_c('div',{staticClass:"el-table-filter__content"},[_c('el-scrollbar',{attrs:{"wrap-class":"el-table-filter__wrap"}},[_c('el-checkbox-group',{staticClass:"el-table-filter__checkbox-group",model:{value:(_vm.filteredValue),callback:function ($$v) {_vm.filteredValue=$$v},expression:"filteredValue"}},_vm._l((_vm.filters),function(filter){return _c('el-checkbox',{key:filter.value,attrs:{"label":filter.value}},[_vm._v(_vm._s(filter.text))])}))],1)],1),_c('div',{staticClass:"el-table-filter__bottom"},[_c('button',{class:{ 'is-disabled': _vm.filteredValue.length === 0 },attrs:{"disabled":_vm.filteredValue.length === 0},on:{"click":_vm.handleConfirm}},[_vm._v(_vm._s(_vm.t('el.table.confirmFilter')))]),_c('button',{on:{"click":_vm.handleReset}},[_vm._v(_vm._s(_vm.t('el.table.resetFilter')))])])]):_c('div',{directives:[{name:"clickoutside",rawName:"v-clickoutside",value:(_vm.handleOutsideClick),expression:"handleOutsideClick"},{name:"show",rawName:"v-show",value:(_vm.showPopper),expression:"showPopper"}],staticClass:"el-table-filter"},[_c('ul',{staticClass:"el-table-filter__list"},[_c('li',{staticClass:"el-table-filter__list-item",class:{ 'is-active': _vm.filterValue === undefined || _vm.filterValue === null },on:{"click":function($event){_vm.handleSelect(null)}}},[_vm._v(_vm._s(_vm.t('el.table.clearFilter')))]),_vm._l((_vm.filters),function(filter){return _c('li',{key:filter.value,staticClass:"el-table-filter__list-item",class:{ 'is-active': _vm.isActive(filter) },attrs:{"label":filter.value},on:{"click":function($event){_vm.handleSelect(filter.value)}}},[_vm._v(_vm._s(filter.text))])})],2)])])}
+var staticRenderFns = []
+var esExports = { render: render, staticRenderFns: staticRenderFns }
+/* harmony default export */ __webpack_exports__["a"] = (esExports);
+
+/***/ }),
+
+/***/ 172:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+exports.__esModule = true;
+
+var _layoutObserver = __webpack_require__(39);
+
+var _layoutObserver2 = _interopRequireDefault(_layoutObserver);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = {
+  name: 'ElTableFooter',
+
+  mixins: [_layoutObserver2.default],
+
+  render: function render(h) {
+    var _this = this;
+
+    var sums = [];
+    if (this.summaryMethod) {
+      sums = this.summaryMethod({ columns: this.columns, data: this.store.states.data });
+    } else {
+      this.columns.forEach(function (column, index) {
+        if (index === 0) {
+          sums[index] = _this.sumText;
+          return;
+        }
+        var values = _this.store.states.data.map(function (item) {
+          return Number(item[column.property]);
+        });
+        var precisions = [];
+        var notNumber = true;
+        values.forEach(function (value) {
+          if (!isNaN(value)) {
+            notNumber = false;
+            var decimal = ('' + value).split('.')[1];
+            precisions.push(decimal ? decimal.length : 0);
+          }
+        });
+        var precision = Math.max.apply(null, precisions);
+        if (!notNumber) {
+          sums[index] = values.reduce(function (prev, curr) {
+            var value = Number(curr);
+            if (!isNaN(value)) {
+              return parseFloat((prev + curr).toFixed(Math.min(precision, 20)));
+            } else {
+              return prev;
+            }
+          }, 0);
+        } else {
+          sums[index] = '';
+        }
+      });
+    }
+
+    return h(
+      'table',
+      {
+        'class': 'el-table__footer',
+        attrs: { cellspacing: '0',
+          cellpadding: '0',
+          border: '0' }
+      },
+      [h(
+        'colgroup',
+        null,
+        [this._l(this.columns, function (column) {
+          return h(
+            'col',
+            {
+              attrs: { name: column.id }
+            },
+            []
+          );
+        }), this.hasGutter ? h(
+          'col',
+          {
+            attrs: { name: 'gutter' }
+          },
+          []
+        ) : '']
+      ), h(
+        'tbody',
+        { 'class': [{ 'has-gutter': this.hasGutter }] },
+        [h(
+          'tr',
+          null,
+          [this._l(this.columns, function (column, cellIndex) {
+            return h(
+              'td',
+              {
+                attrs: {
+                  colspan: column.colSpan,
+                  rowspan: column.rowSpan
+                },
+                'class': [column.id, column.headerAlign, column.className || '', _this.isCellHidden(cellIndex, _this.columns) ? 'is-hidden' : '', !column.children ? 'is-leaf' : '', column.labelClassName] },
+              [h(
+                'div',
+                { 'class': ['cell', column.labelClassName] },
+                [sums[cellIndex]]
+              )]
+            );
+          }), this.hasGutter ? h(
+            'th',
+            { 'class': 'gutter' },
+            []
+          ) : '']
+        )]
+      )]
+    );
+  },
+
+
+  props: {
+    fixed: String,
+    store: {
+      required: true
+    },
+    summaryMethod: Function,
+    sumText: String,
+    border: Boolean,
+    defaultSort: {
+      type: Object,
+      default: function _default() {
+        return {
+          prop: '',
+          order: ''
+        };
+      }
+    }
+  },
+
+  computed: {
+    table: function table() {
+      return this.$parent;
+    },
+    isAllSelected: function isAllSelected() {
+      return this.store.states.isAllSelected;
+    },
+    columnsCount: function columnsCount() {
+      return this.store.states.columns.length;
+    },
+    leftFixedCount: function leftFixedCount() {
+      return this.store.states.fixedColumns.length;
+    },
+    rightFixedCount: function rightFixedCount() {
+      return this.store.states.rightFixedColumns.length;
+    },
+    columns: function columns() {
+      return this.store.states.columns;
+    },
+    hasGutter: function hasGutter() {
+      return !this.fixed && this.tableLayout.gutterWidth;
+    }
+  },
+
+  methods: {
+    isCellHidden: function isCellHidden(index, columns) {
+      if (this.fixed === true || this.fixed === 'left') {
+        return index >= this.leftFixedCount;
+      } else if (this.fixed === 'right') {
+        var before = 0;
+        for (var i = 0; i < index; i++) {
+          before += columns[i].colSpan;
+        }
+        return before < this.columnsCount - this.rightFixedCount;
+      } else {
+        return index < this.leftFixedCount || index >= this.columnsCount - this.rightFixedCount;
+      }
+    }
+  }
+};
+
+/***/ }),
+
+/***/ 173:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticClass:"el-table",class:[{
+    'el-table--fit': _vm.fit,
+    'el-table--striped': _vm.stripe,
+    'el-table--border': _vm.border || _vm.isGroup,
+    'el-table--hidden': _vm.isHidden,
+    'el-table--group': _vm.isGroup,
+    'el-table--fluid-height': _vm.maxHeight,
+    'el-table--scrollable-x': _vm.layout.scrollX,
+    'el-table--scrollable-y': _vm.layout.scrollY,
+    'el-table--enable-row-hover': !_vm.store.states.isComplex,
+    'el-table--enable-row-transition': (_vm.store.states.data || []).length !== 0 && (_vm.store.states.data || []).length < 100
+  }, _vm.tableSize ? ("el-table--" + _vm.tableSize) : ''],on:{"mouseleave":function($event){_vm.handleMouseLeave($event)}}},[_c('div',{ref:"hiddenColumns",staticClass:"hidden-columns"},[_vm._t("default")],2),(_vm.showHeader)?_c('div',{directives:[{name:"mousewheel",rawName:"v-mousewheel",value:(_vm.handleHeaderFooterMousewheel),expression:"handleHeaderFooterMousewheel"}],ref:"headerWrapper",staticClass:"el-table__header-wrapper"},[_c('table-header',{ref:"tableHeader",style:({
+        width: _vm.layout.bodyWidth ? _vm.layout.bodyWidth + 'px' : ''
+      }),attrs:{"store":_vm.store,"border":_vm.border,"default-sort":_vm.defaultSort}})],1):_vm._e(),_c('div',{ref:"bodyWrapper",staticClass:"el-table__body-wrapper",class:[_vm.layout.scrollX ? ("is-scrolling-" + _vm.scrollPosition) : 'is-scrolling-none'],style:([_vm.bodyHeight])},[_c('table-body',{style:({
+         width: _vm.bodyWidth
+      }),attrs:{"context":_vm.context,"store":_vm.store,"stripe":_vm.stripe,"row-class-name":_vm.rowClassName,"row-style":_vm.rowStyle,"highlight":_vm.highlightCurrentRow}}),(!_vm.data || _vm.data.length === 0)?_c('div',{ref:"emptyBlock",staticClass:"el-table__empty-block",style:({
+        width: _vm.bodyWidth
+      })},[_c('span',{staticClass:"el-table__empty-text"},[_vm._t("empty",[_vm._v(_vm._s(_vm.emptyText || _vm.t('el.table.emptyText')))])],2)]):_vm._e(),(_vm.$slots.append)?_c('div',{ref:"appendWrapper",staticClass:"el-table__append-wrapper"},[_vm._t("append")],2):_vm._e()],1),(_vm.showSummary)?_c('div',{directives:[{name:"show",rawName:"v-show",value:(_vm.data && _vm.data.length > 0),expression:"data && data.length > 0"},{name:"mousewheel",rawName:"v-mousewheel",value:(_vm.handleHeaderFooterMousewheel),expression:"handleHeaderFooterMousewheel"}],ref:"footerWrapper",staticClass:"el-table__footer-wrapper"},[_c('table-footer',{style:({
+        width: _vm.layout.bodyWidth ? _vm.layout.bodyWidth + 'px' : ''
+      }),attrs:{"store":_vm.store,"border":_vm.border,"sum-text":_vm.sumText || _vm.t('el.table.sumText'),"summary-method":_vm.summaryMethod,"default-sort":_vm.defaultSort}})],1):_vm._e(),(_vm.fixedColumns.length > 0)?_c('div',{directives:[{name:"mousewheel",rawName:"v-mousewheel",value:(_vm.handleFixedMousewheel),expression:"handleFixedMousewheel"}],ref:"fixedWrapper",staticClass:"el-table__fixed",style:([{
+      width: _vm.layout.fixedWidth ? _vm.layout.fixedWidth + 'px' : ''
+    },
+    _vm.fixedHeight])},[(_vm.showHeader)?_c('div',{ref:"fixedHeaderWrapper",staticClass:"el-table__fixed-header-wrapper"},[_c('table-header',{ref:"fixedTableHeader",style:({
+          width: _vm.bodyWidth
+        }),attrs:{"fixed":"left","border":_vm.border,"store":_vm.store}})],1):_vm._e(),_c('div',{ref:"fixedBodyWrapper",staticClass:"el-table__fixed-body-wrapper",style:([{
+        top: _vm.layout.headerHeight + 'px'
+      },
+      _vm.fixedBodyHeight])},[_c('table-body',{style:({
+          width: _vm.bodyWidth
+        }),attrs:{"fixed":"left","store":_vm.store,"stripe":_vm.stripe,"highlight":_vm.highlightCurrentRow,"row-class-name":_vm.rowClassName,"row-style":_vm.rowStyle}}),(_vm.$slots.append)?_c('div',{staticClass:"el-table__append-gutter",style:({
+          height: _vm.layout.appendHeight + 'px'
+        })}):_vm._e()],1),(_vm.showSummary)?_c('div',{directives:[{name:"show",rawName:"v-show",value:(_vm.data && _vm.data.length > 0),expression:"data && data.length > 0"}],ref:"fixedFooterWrapper",staticClass:"el-table__fixed-footer-wrapper"},[_c('table-footer',{style:({
+          width: _vm.bodyWidth
+        }),attrs:{"fixed":"left","border":_vm.border,"sum-text":_vm.sumText || _vm.t('el.table.sumText'),"summary-method":_vm.summaryMethod,"store":_vm.store}})],1):_vm._e()]):_vm._e(),(_vm.rightFixedColumns.length > 0)?_c('div',{directives:[{name:"mousewheel",rawName:"v-mousewheel",value:(_vm.handleFixedMousewheel),expression:"handleFixedMousewheel"}],ref:"rightFixedWrapper",staticClass:"el-table__fixed-right",style:([{
+      width: _vm.layout.rightFixedWidth ? _vm.layout.rightFixedWidth + 'px' : '',
+      right: _vm.layout.scrollY ? (_vm.border ? _vm.layout.gutterWidth : (_vm.layout.gutterWidth || 0)) + 'px' : ''
+    },
+    _vm.fixedHeight])},[(_vm.showHeader)?_c('div',{ref:"rightFixedHeaderWrapper",staticClass:"el-table__fixed-header-wrapper"},[_c('table-header',{ref:"rightFixedTableHeader",style:({
+          width: _vm.bodyWidth
+        }),attrs:{"fixed":"right","border":_vm.border,"store":_vm.store}})],1):_vm._e(),_c('div',{ref:"rightFixedBodyWrapper",staticClass:"el-table__fixed-body-wrapper",style:([{
+        top: _vm.layout.headerHeight + 'px'
+      },
+      _vm.fixedBodyHeight])},[_c('table-body',{style:({
+          width: _vm.bodyWidth
+        }),attrs:{"fixed":"right","store":_vm.store,"stripe":_vm.stripe,"row-class-name":_vm.rowClassName,"row-style":_vm.rowStyle,"highlight":_vm.highlightCurrentRow}})],1),(_vm.showSummary)?_c('div',{directives:[{name:"show",rawName:"v-show",value:(_vm.data && _vm.data.length > 0),expression:"data && data.length > 0"}],ref:"rightFixedFooterWrapper",staticClass:"el-table__fixed-footer-wrapper"},[_c('table-footer',{style:({
+          width: _vm.bodyWidth
+        }),attrs:{"fixed":"right","border":_vm.border,"sum-text":_vm.sumText || _vm.t('el.table.sumText'),"summary-method":_vm.summaryMethod,"store":_vm.store}})],1):_vm._e()]):_vm._e(),(_vm.rightFixedColumns.length > 0)?_c('div',{ref:"rightFixedPatch",staticClass:"el-table__fixed-right-patch",style:({
+      width: _vm.layout.scrollY ? _vm.layout.gutterWidth + 'px' : '0',
+      height: _vm.layout.headerHeight + 'px'
+    })}):_vm._e(),_c('div',{directives:[{name:"show",rawName:"v-show",value:(_vm.resizeProxyVisible),expression:"resizeProxyVisible"}],ref:"resizeProxy",staticClass:"el-table__column-resize-proxy"})])}
+var staticRenderFns = []
+var esExports = { render: render, staticRenderFns: staticRenderFns }
+/* harmony default export */ __webpack_exports__["a"] = (esExports);
+
+/***/ }),
+
+/***/ 18:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/utils/resize-event");
+
+/***/ }),
+
+/***/ 2:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/utils/util");
+
+/***/ }),
+
+/***/ 22:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/tooltip");
+
+/***/ }),
+
+/***/ 25:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/tag");
+
+/***/ }),
+
+/***/ 3:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/utils/dom");
+
+/***/ }),
+
+/***/ 38:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/utils/scrollbar-width");
+
+/***/ }),
+
+/***/ 39:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+exports.__esModule = true;
+exports.default = {
+  created: function created() {
+    this.tableLayout.addObserver(this);
+  },
+  destroyed: function destroyed() {
+    this.tableLayout.removeObserver(this);
+  },
+
+
+  computed: {
+    tableLayout: function tableLayout() {
+      var layout = this.layout;
+      if (!layout && this.table) {
+        layout = this.table.layout;
+      }
+      if (!layout) {
+        throw new Error('Can not find table layout.');
+      }
+      return layout;
+    }
+  },
+
+  mounted: function mounted() {
+    this.onColumnsChange(this.tableLayout);
+    this.onScrollableChange(this.tableLayout);
+  },
+  updated: function updated() {
+    if (this.__updated__) return;
+    this.onColumnsChange(this.tableLayout);
+    this.onScrollableChange(this.tableLayout);
+    this.__updated__ = true;
+  },
+
+
+  methods: {
+    onColumnsChange: function onColumnsChange() {
+      var cols = this.$el.querySelectorAll('colgroup > col');
+      if (!cols.length) return;
+      var flattenColumns = this.tableLayout.getFlattenColumns();
+      var columnsMap = {};
+      flattenColumns.forEach(function (column) {
+        columnsMap[column.id] = column;
+      });
+      for (var i = 0, j = cols.length; i < j; i++) {
+        var col = cols[i];
+        var name = col.getAttribute('name');
+        var column = columnsMap[name];
+        if (column) {
+          col.setAttribute('width', column.realWidth || column.width);
+        }
+      }
+    },
+    onScrollableChange: function onScrollableChange(layout) {
+      var cols = this.$el.querySelectorAll('colgroup > col[name=gutter]');
+      for (var i = 0, j = cols.length; i < j; i++) {
+        var col = cols[i];
+        col.setAttribute('width', layout.scrollY ? layout.gutterWidth : '0');
+      }
+      var ths = this.$el.querySelectorAll('th.gutter');
+      for (var _i = 0, _j = ths.length; _i < _j; _i++) {
+        var th = ths[_i];
+        th.style.width = layout.scrollY ? layout.gutterWidth + 'px' : '0';
+        th.style.display = layout.scrollY ? '' : 'none';
+      }
+    }
+  }
+};
+
+/***/ }),
+
+/***/ 4:
+/***/ (function(module, exports) {
+
+module.exports = require("vue");
+
+/***/ }),
+
+/***/ 40:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/checkbox-group");
+
+/***/ }),
+
+/***/ 48:
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+exports.__esModule = true;
+exports.getRowIdentity = exports.getColumnByCell = exports.getColumnByKey = exports.getColumnById = exports.orderBy = exports.getCell = 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 _util = __webpack_require__(2);
+
+var getCell = exports.getCell = function getCell(event) {
+  var cell = event.target;
+
+  while (cell && cell.tagName.toUpperCase() !== 'HTML') {
+    if (cell.tagName.toUpperCase() === 'TD') {
+      return cell;
+    }
+    cell = cell.parentNode;
+  }
+
+  return null;
+};
+
+var isObject = function isObject(obj) {
+  return obj !== null && (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object';
+};
+
+var orderBy = exports.orderBy = function orderBy(array, sortKey, reverse, sortMethod, sortBy) {
+  if (!sortKey && !sortMethod && (!sortBy || Array.isArray(sortBy) && !sortBy.length)) {
+    return array;
+  }
+  if (typeof reverse === 'string') {
+    reverse = reverse === 'descending' ? -1 : 1;
+  } else {
+    reverse = reverse && reverse < 0 ? -1 : 1;
+  }
+  var getKey = sortMethod ? null : function (value, index) {
+    if (sortBy) {
+      if (!Array.isArray(sortBy)) {
+        sortBy = [sortBy];
+      }
+      return sortBy.map(function (by) {
+        if (typeof by === 'string') {
+          return (0, _util.getValueByPath)(value, by);
+        } else {
+          return by(value, index, array);
+        }
+      });
+    }
+    if (sortKey !== '$key') {
+      if (isObject(value) && '$value' in value) value = value.$value;
+    }
+    return [isObject(value) ? (0, _util.getValueByPath)(value, sortKey) : value];
+  };
+  var compare = function compare(a, b) {
+    if (sortMethod) {
+      return sortMethod(a.value, b.value);
+    }
+    for (var i = 0, len = a.key.length; i < len; i++) {
+      if (a.key[i] < b.key[i]) {
+        return -1;
+      }
+      if (a.key[i] > b.key[i]) {
+        return 1;
+      }
+    }
+    return 0;
+  };
+  return array.map(function (value, index) {
+    return {
+      value: value,
+      index: index,
+      key: getKey ? getKey(value, index) : null
+    };
+  }).sort(function (a, b) {
+    var order = compare(a, b);
+    if (!order) {
+      // make stable https://en.wikipedia.org/wiki/Sorting_algorithm#Stability
+      order = a.index - b.index;
+    }
+    return order * reverse;
+  }).map(function (item) {
+    return item.value;
+  });
+};
+
+var getColumnById = exports.getColumnById = function getColumnById(table, columnId) {
+  var column = null;
+  table.columns.forEach(function (item) {
+    if (item.id === columnId) {
+      column = item;
+    }
+  });
+  return column;
+};
+
+var getColumnByKey = exports.getColumnByKey = function getColumnByKey(table, columnKey) {
+  var column = null;
+  for (var i = 0; i < table.columns.length; i++) {
+    var item = table.columns[i];
+    if (item.columnKey === columnKey) {
+      column = item;
+      break;
+    }
+  }
+  return column;
+};
+
+var getColumnByCell = exports.getColumnByCell = function getColumnByCell(table, cell) {
+  var matches = (cell.className || '').match(/el-table_[^\s]+/gm);
+  if (matches) {
+    return getColumnById(table, matches[0]);
+  }
+  return null;
+};
+
+var getRowIdentity = exports.getRowIdentity = function getRowIdentity(row, rowKey) {
+  if (!row) throw new Error('row is required when get row identity');
+  if (typeof rowKey === 'string') {
+    if (rowKey.indexOf('.') < 0) {
+      return row[rowKey];
+    }
+    var key = rowKey.split('.');
+    var current = row;
+    for (var i = 0; i < key.length; i++) {
+      current = current[key[i]];
+    }
+    return current;
+  } else if (typeof rowKey === 'function') {
+    return rowKey.call(null, row);
+  }
+};
+
+/***/ }),
+
+/***/ 5:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/mixins/locale");
+
+/***/ }),
+
+/***/ 7:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/utils/vue-popper");
+
+/***/ }),
+
+/***/ 8:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/mixins/migrating");
+
+/***/ }),
+
+/***/ 9:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/utils/merge");
+
+/***/ })
+
+/******/ });