text: 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, { enumerable: true, get: getter });
  /******/ 		}
  /******/ 	};
  /******/
  /******/ 	// define __esModule on exports
  /******/ 	__webpack_require__.r = function(exports) {
  /******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
  /******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
  /******/ 		}
  /******/ 		Object.defineProperty(exports, '__esModule', { value: true });
  /******/ 	};
  /******/
  /******/ 	// create a fake namespace object
  /******/ 	// mode & 1: value is a module id, require it
  /******/ 	// mode & 2: merge all properties of value into the ns
  /******/ 	// mode & 4: return value when already ns object
  /******/ 	// mode & 8|1: behave like require
  /******/ 	__webpack_require__.t = function(value, mode) {
  /******/ 		if(mode & 1) value = __webpack_require__(value);
  /******/ 		if(mode & 8) return value;
  /******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
  /******/ 		var ns = Object.create(null);
  /******/ 		__webpack_require__.r(ns);
  /******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
  /******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
  /******/ 		return ns;
  /******/ 	};
  /******/
  /******/ 	// 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 = 27);
  /******/ })
  /************************************************************************/
  /******/ ({
  
  /***/ 0:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return getCell; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "i", function() { return orderBy; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "d", function() { return getColumnById; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "e", function() { return getColumnByKey; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "c", function() { return getColumnByCell; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "g", function() { return getRowIdentity; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "f", function() { return getKeysMap; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "h", function() { return mergeOptions; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "l", function() { return parseWidth; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "k", function() { return parseMinWidth; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "j", function() { return parseHeight; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return compose; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "m", function() { return toggleRowStatus; });
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "n", function() { return walkTreeNode; });
  /* harmony import */ var pl_table_src_utils_util__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1);
  /* harmony import */ var pl_table_src_utils_util__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(pl_table_src_utils_util__WEBPACK_IMPORTED_MODULE_0__);
  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 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 = 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 Object(pl_table_src_utils_util__WEBPACK_IMPORTED_MODULE_0__["getValueByPath"])(value, by);
          } else {
            return by(value, index, array);
          }
        });
      }
      if (sortKey !== '$key') {
        if (isObject(value) && '$value' in value) value = value.$value;
      }
      return [isObject(value) ? Object(pl_table_src_utils_util__WEBPACK_IMPORTED_MODULE_0__["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 = function getColumnById(table, columnId) {
    var column = null;
    table.columns.forEach(function (item) {
      if (item.id === columnId) {
        column = item;
      }
    });
    return column;
  };
  
  var 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 = function getColumnByCell(table, cell) {
    var matches = (cell.className || '').match(/el-table_[^\s]+/gm);
    if (matches) {
      return getColumnById(table, matches[0]);
    }
    return null;
  };
  
  var 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);
    }
  };
  
  var getKeysMap = function getKeysMap(array, rowKey) {
    var arrayMap = {};
    (array || []).forEach(function (row, index) {
      arrayMap[getRowIdentity(row, rowKey)] = { row: row, index: index };
    });
    return arrayMap;
  };
  
  function hasOwn(obj, key) {
    return Object.prototype.hasOwnProperty.call(obj, key);
  }
  
  function mergeOptions(defaults, config) {
    var options = {};
    var key = void 0;
    for (key in defaults) {
      options[key] = defaults[key];
    }
    for (key in config) {
      if (hasOwn(config, key)) {
        var value = config[key];
        if (typeof value !== 'undefined') {
          options[key] = value;
        }
      }
    }
    return options;
  }
  
  function parseWidth(width) {
    if (width !== undefined) {
      width = parseInt(width, 10);
      if (isNaN(width)) {
        width = null;
      }
    }
    return width;
  }
  
  function parseMinWidth(minWidth) {
    if (typeof minWidth !== 'undefined') {
      minWidth = parseWidth(minWidth);
      if (isNaN(minWidth)) {
        minWidth = 80;
      }
    }
    return minWidth;
  };
  
  function parseHeight(height) {
    if (typeof height === 'number') {
      return height;
    }
    if (typeof height === 'string') {
      if (/^\d+(?:px)?$/.test(height)) {
        return parseInt(height, 10);
      } else {
        return height;
      }
    }
    return null;
  }
  
  // https://github.com/reduxjs/redux/blob/master/src/compose.js
  function compose() {
    for (var _len = arguments.length, funcs = Array(_len), _key = 0; _key < _len; _key++) {
      funcs[_key] = arguments[_key];
    }
  
    if (funcs.length === 0) {
      return function (arg) {
        return arg;
      };
    }
    if (funcs.length === 1) {
      return funcs[0];
    }
    return funcs.reduce(function (a, b) {
      return function () {
        return a(b.apply(undefined, arguments));
      };
    });
  }
  
  function toggleRowStatus(statusArr, row, newVal, _this) {
    var changed = false;
    var index = statusArr.indexOf(row);
    var included = index !== -1;
    var addRow = function addRow() {
      if (_this && _this.states.useVirtual && _this.states.bigDataCheckbox) {
        row.plChoose = true;
        statusArr.push(row);
        changed = true;
      } else {
        statusArr.push(row);
        changed = true;
      }
    };
  
    var removeRow = function removeRow() {
      // 如果我是大数据渲染，并且全选，那么我不管勾上还是取消都会执行removeRow，不会执行addRow，因为大数据全选不一样
      // 修改源码: 如果我当前是大数据渲染模式并且当前是全选模式
      // 就不能执行删除statusArr数组操作，这样会把表格数据也删除了，因为里面是数组的引用
      if (_this && _this.states.useVirtual && _this.states.bigDataCheckbox) {
        if (statusArr[index].plChoose === undefined) {
          statusArr[index].plChoose = false;
        }
        statusArr[index].plChoose = !statusArr[index].plChoose;
        // 更新表格数据，需要手动更新，因为这里大数据渲染，el-checkbox数据是引用数据赋值，而ele是不跟原始表格数据关联的
        // 先把当前获取焦点hoverRow赋值给变量hoverRow2
        var hoverRow2 = _this.states.hoverRow;
        // 然后改变states的hoverRow值
        _this.states.hoverRow = -1;
        // 异步赋值回去当前获取焦点的hoverRow，从而更新视图 （很重要）
        _this.table.$nextTick(function () {
          _this.states.hoverRow = hoverRow2;
        });
        changed = true;
      } else {
        statusArr.splice(index, 1);
        changed = true;
      }
    };
  
    if (typeof newVal === 'boolean') {
      if (newVal && !included) {
        addRow();
      } else if (!newVal && included) {
        removeRow();
      }
    } else {
      if (included) {
        removeRow();
      } else {
        addRow();
      }
    }
    return changed;
  }
  
  function walkTreeNode(root, cb) {
    var childrenKey = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'children';
    var lazyKey = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'hasChildren';
  
    var isNil = function isNil(array) {
      return !(Array.isArray(array) && array.length);
    };
  
    function _walker(parent, children, level) {
      cb(parent, children, level);
      children.forEach(function (item) {
        if (item[lazyKey]) {
          cb(item, null, level + 1);
          return;
        }
        var children = item[childrenKey];
        if (!isNil(children)) {
          _walker(item, children, level + 1);
        }
      });
    }
  
    root.forEach(function (item) {
      if (item[lazyKey]) {
        cb(item, null, 0);
        return;
      }
      var children = item[childrenKey];
      if (!isNil(children)) {
        _walker(item, children, 0);
      }
    });
  }
  
  /***/ }),
  
  /***/ 1:
  /***/ (function(module, exports) {
  
  module.exports = require("pl-table/lib/utils/util");
  
  /***/ }),
  
  /***/ 27:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  __webpack_require__.r(__webpack_exports__);
  
  // EXTERNAL MODULE: external "pl-table/lib/utils/util"
  var util_ = __webpack_require__(1);
  
  // CONCATENATED MODULE: ./packages/table/src/config.js
  
  
  var cellStarts = {
    default: {
      order: ''
    },
    selection: {
      width: 48,
      minWidth: 48,
      realWidth: 48,
      order: '',
      className: 'el-table-column--selection'
    },
    expand: {
      width: 48,
      minWidth: 48,
      realWidth: 48,
      order: ''
    },
    index: {
      width: 48,
      minWidth: 48,
      realWidth: 48,
      order: ''
    }
  };
  
  // 这些选项不应该被覆盖
  var cellForced = {
    selection: {
      renderHeader: function renderHeader(h, _ref) {
        var store = _ref.store;
  
        return h('el-checkbox', {
          attrs: {
            disabled: store.states.data && store.states.data.length === 0
            // 修改源码: 如果我当前是大数据模式，那么就不在依据isAllSelected判断当前checkbox是否为不确定状态
            , indeterminate: store.states.useVirtual && store.states.bigDataCheckbox ? !store.states.newisAllSelected : store.states.selection.length > 0 && !this.isAllSelected,
  
            value: this.isAllSelected },
          nativeOn: {
            'click': this.toggleAllSelection
          }
        });
      },
      renderCell: function renderCell(h, _ref2) {
        var row = _ref2.row,
            column = _ref2.column,
            store = _ref2.store,
            $index = _ref2.$index;
  
        return h('el-checkbox', {
          nativeOn: {
            'click': function click(event) {
              return event.stopPropagation();
            }
          },
          attrs: {
            value: store.isSelected(row),
            disabled: column.selectable ? !column.selectable.call(null, row, $index) : false
          },
          on: {
            'input': function input() {
              store.commit('rowSelectedChanged', row);
            }
          }
        });
      },
      sortable: false,
      resizable: false
    },
    index: {
      renderHeader: function renderHeader(h, _ref3) {
        var column = _ref3.column;
  
        return column.label || '#';
      },
      renderCell: function renderCell(h, _ref4) {
        var $index = _ref4.$index,
            column = _ref4.column;
  
        var i = $index + 1;
        var index = column.index;
  
        if (typeof index === 'number') {
          i = $index + index;
        } else if (typeof index === 'function') {
          i = index($index);
        }
  
        return h('div', [i]);
      },
      sortable: false
    },
    expand: {
      renderHeader: function renderHeader(h, _ref5) {
        var column = _ref5.column;
  
        return column.label || '';
      },
      renderCell: function renderCell(h, _ref6) {
        var row = _ref6.row,
            store = _ref6.store;
  
        var classes = ['el-table__expand-icon'];
        if (store.states.expandRows.indexOf(row) > -1) {
          classes.push('el-table__expand-icon--expanded');
        }
        var callback = function callback(e) {
          e.stopPropagation();
          store.toggleRowExpansion(row);
        };
        return h(
          'div',
          { 'class': classes,
            on: {
              'click': callback
            }
          },
          [h('i', { 'class': 'el-icon el-icon-arrow-right' })]
        );
      },
      sortable: false,
      resizable: false,
      className: 'el-table__expand-column'
    }
  };
  
  function defaultRenderCell(h, _ref7) {
    var row = _ref7.row,
        column = _ref7.column,
        $index = _ref7.$index;
  
    var property = column.property;
    var value = property && Object(util_["getPropByPath"])(row, property).v;
    if (column && column.formatter) {
      return column.formatter(row, column, value, $index);
    }
    return value;
  }
  
  function treeCellPrefix(h, _ref8) {
    var row = _ref8.row,
        treeNode = _ref8.treeNode,
        store = _ref8.store;
  
    if (!treeNode) return null;
    var ele = [];
    var callback = function callback(e) {
      e.stopPropagation();
      store.loadOrToggle(row);
    };
    if (treeNode.indent) {
      ele.push(h('span', { 'class': 'el-table__indent', style: { 'padding-left': treeNode.indent + 'px' } }));
    }
    if (typeof treeNode.expanded === 'boolean' && !treeNode.noLazyChildren) {
      var expandClasses = ['el-table__expand-icon', treeNode.expanded ? 'el-table__expand-icon--expanded' : ''];
      var iconClasses = ['el-icon-arrow-right'];
      if (treeNode.loading) {
        iconClasses = ['el-icon-loading'];
      }
      ele.push(h(
        'div',
        { 'class': expandClasses,
          on: {
            'click': callback
          }
        },
        [h('i', { 'class': iconClasses })]
      ));
    } else {
      ele.push(h('span', { 'class': 'el-table__placeholder' }));
    }
    return ele;
  }
  // EXTERNAL MODULE: ./packages/table/src/util.js
  var util = __webpack_require__(0);
  
  // EXTERNAL MODULE: ./packages/checkbox/index.js + 5 modules
  var packages_checkbox = __webpack_require__(6);
  
  // CONCATENATED MODULE: ./packages/table/src/table-column.js
  var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
  
  
  
  
  
  var columnIdSeed = 1;
  
  /* harmony default export */ var table_column = ({
    name: 'PlTableColumn',
    props: {
      type: {
        type: String,
        default: 'default'
      },
      dropAction: {
        type: Boolean,
        default: false
      }, // 修改源码 pl-table添加掉落元素列，解决表格多一列出现右边线框问题
      label: String,
      className: String,
      labelClassName: String,
      property: String,
      prop: String,
      width: {},
      minWidth: {},
      renderHeader: Function,
      sortable: {
        type: [Boolean, String],
        default: false
      },
      sortMethod: Function,
      sortBy: [String, Function, Array],
      resizable: {
        type: Boolean,
        default: true
      },
      columnKey: String,
      align: String,
      headerAlign: String,
      showTooltipWhenOverflow: Boolean,
      showOverflowTooltip: Boolean,
      fixed: [Boolean, String],
      formatter: Function,
      selectable: Function,
      reserveSelection: Boolean,
      filterMethod: Function,
      filteredValue: Array,
      filters: Array,
      filterPlacement: String,
      filterMultiple: {
        type: Boolean,
        default: true
      },
      index: [Number, Function],
      sortOrders: {
        type: Array,
        default: function _default() {
          return ['ascending', 'descending', null];
        },
        validator: function validator(val) {
          return val.every(function (order) {
            return ['ascending', 'descending', null].indexOf(order) > -1;
          });
        }
      }
    },
  
    data: function data() {
      return {
        isSubColumn: false,
        columns: []
      };
    },
  
  
    computed: {
      owner: function owner() {
        var parent = this.$parent;
        while (parent && !parent.tableId) {
          parent = parent.$parent;
        }
        return parent;
      },
      columnOrTableParent: function columnOrTableParent() {
        var parent = this.$parent;
        while (parent && !parent.tableId && !parent.columnId) {
          parent = parent.$parent;
        }
        return parent;
      },
      realWidth: function realWidth() {
        return Object(util["l" /* parseWidth */])(this.width);
      },
      realMinWidth: function realMinWidth() {
        return Object(util["k" /* parseMinWidth */])(this.minWidth);
      },
      realAlign: function realAlign() {
        return this.align ? 'is-' + this.align : null;
      },
      realHeaderAlign: function realHeaderAlign() {
        return this.headerAlign ? 'is-' + this.headerAlign : this.realAlign;
      }
    },
  
    methods: {
      getPropsData: function getPropsData() {
        var _this = this;
  
        for (var _len = arguments.length, props = Array(_len), _key = 0; _key < _len; _key++) {
          props[_key] = arguments[_key];
        }
  
        return props.reduce(function (prev, cur) {
          if (Array.isArray(cur)) {
            cur.forEach(function (key) {
              prev[key] = _this[key];
            });
          }
          return prev;
        }, {});
      },
      getColumnElIndex: function getColumnElIndex(children, child) {
        return [].indexOf.call(children, child);
      },
      setColumnWidth: function setColumnWidth(column) {
        if (this.realWidth) {
          column.width = this.realWidth;
        }
        if (this.realMinWidth) {
          column.minWidth = this.realMinWidth;
        }
        if (!column.minWidth) {
          column.minWidth = 80;
        }
        column.realWidth = column.width === undefined ? column.minWidth : column.width;
        return column;
      },
      setColumnForcedProps: function setColumnForcedProps(column) {
        // 对于特定类型的 column，某些属性不允许设置
        var type = column.type;
        var source = cellForced[type] || {};
        Object.keys(source).forEach(function (prop) {
          var value = source[prop];
          if (value !== undefined) {
            column[prop] = prop === 'className' ? column[prop] + ' ' + value : value;
          }
        });
        return column;
      },
      setColumnRenders: function setColumnRenders(column) {
        var _this2 = this;
  
        var h = this.$createElement;
  
        var specialTypes = Object.keys(cellForced);
        // renderHeader 属性不推荐使用。
        if (this.renderHeader) {
          console.warn('[Element Warn][TableColumn]Comparing to render-header, scoped-slot header is easier to use. We recommend users to use scoped-slot header.');
        } else if (specialTypes.indexOf(column.type) === -1) {
          column.renderHeader = function (h, scope) {
            var renderHeader = _this2.$scopedSlots.header;
            return renderHeader ? renderHeader(scope) : column.label;
          };
        }
  
        var originRenderCell = column.renderCell;
        // TODO: 这里的实现调整
        if (column.type === 'expand') {
          // 对于展开行，renderCell 不允许配置的。在上一步中已经设置过，这里需要简单封装一下。
          column.renderCell = function (h, data) {
            return h(
              'div',
              { 'class': 'cell' },
              [originRenderCell(h, data)]
            );
          };
          this.owner.renderExpanded = function (h, data) {
            return _this2.$scopedSlots.default ? _this2.$scopedSlots.default(data) : _this2.$slots.default;
          };
        } else {
          originRenderCell = originRenderCell || defaultRenderCell;
          // 对 renderCell 进行包装
          column.renderCell = function (h, data) {
            var children = null;
            if (_this2.$scopedSlots.default) {
              children = _this2.$scopedSlots.default(data);
            } else {
              children = originRenderCell(h, data);
            }
            var prefix = treeCellPrefix(h, data);
            var props = {
              class: 'cell',
              style: {}
            };
            if (column.showOverflowTooltip) {
              props.class += ' el-tooltip';
              props.style = { width: (data.column.realWidth || data.column.width) - 1 + 'px' };
            }
            // 修改源码如下if语句，当我是大数据渲染模式 并且 开启了thtd超出隐藏，就开启超出隐藏
            if (_this2.$parent.useVirtual && _this2.$parent.thtdBeyondHiding) {
              props.class += ' pl-table-beyond';
              props.style = { width: (data.column.realWidth || data.column.width) - 1 + 'px' };
            }
            return h(
              'div',
              props,
              [prefix, children]
            );
          };
        }
        return column;
      },
      registerNormalWatchers: function registerNormalWatchers() {
        var _this3 = this;
  
        var props = ['label', 'property', 'filters', 'filterMultiple', 'sortable', 'index', 'formatter', 'className', 'labelClassName', 'showOverflowTooltip'];
        // 一些属性具有别名
        var aliases = {
          prop: 'property',
          realAlign: 'align',
          realHeaderAlign: 'headerAlign',
          realWidth: 'width'
        };
        var allAliases = props.reduce(function (prev, cur) {
          prev[cur] = cur;
          return prev;
        }, aliases);
  
        Object.keys(allAliases).forEach(function (key) {
          var columnKey = aliases[key];
  
          _this3.$watch(key, function (newVal) {
            _this3.columnConfig[columnKey] = newVal;
          });
        });
      },
      registerComplexWatchers: function registerComplexWatchers() {
        var _this4 = this;
  
        var props = ['fixed'];
        var aliases = {
          realWidth: 'width',
          realMinWidth: 'minWidth'
        };
        var allAliases = props.reduce(function (prev, cur) {
          prev[cur] = cur;
          return prev;
        }, aliases);
  
        Object.keys(allAliases).forEach(function (key) {
          var columnKey = aliases[key];
  
          _this4.$watch(key, function (newVal) {
            _this4.columnConfig[columnKey] = newVal;
            var updateColumns = columnKey === 'fixed';
            _this4.owner.store.scheduleLayout(updateColumns);
          });
        });
      }
    },
  
    components: {
      ElCheckbox: packages_checkbox["a" /* default */]
    },
  
    beforeCreate: function beforeCreate() {
      this.row = {};
      this.column = {};
      this.$index = 0;
      this.columnId = '';
    },
    created: function created() {
      var parent = this.columnOrTableParent;
      this.isSubColumn = this.owner !== parent;
      this.columnId = (parent.tableId || parent.columnId) + '_column_' + columnIdSeed++;
  
      var type = this.type || 'default';
      var sortable = this.sortable === '' ? true : this.sortable;
      var defaults = _extends({}, cellStarts[type], {
        id: this.columnId,
        type: type,
        property: this.prop || this.property,
        align: this.realAlign,
        headerAlign: this.realHeaderAlign,
        showOverflowTooltip: this.showOverflowTooltip || this.showTooltipWhenOverflow,
        // filter 相关属性
        filterable: this.filters || this.filterMethod,
        filteredValue: [],
        filterPlacement: '',
        isColumnGroup: false,
        filterOpened: false,
        // sort 相关属性
        sortable: sortable,
        // index 列
        index: this.index,
        // 修改源码: 把dropAction开启掉落元素传递进去
        dropAction: this.dropAction
      });
  
      var basicProps = ['columnKey', 'label', 'className', 'labelClassName', 'type', 'renderHeader', 'formatter', 'fixed', 'resizable'];
      var sortProps = ['sortMethod', 'sortBy', 'sortOrders'];
      var selectProps = ['selectable', 'reserveSelection'];
      var filterProps = ['filterMethod', 'filters', 'filterMultiple', 'filterOpened', 'filteredValue', 'filterPlacement'];
  
      var column = this.getPropsData(basicProps, sortProps, selectProps, filterProps);
      column = Object(util["h" /* mergeOptions */])(defaults, column);
  
      // 注意 compose 中函数执行的顺序是从右到左
      var chains = Object(util["a" /* compose */])(this.setColumnRenders, this.setColumnWidth, this.setColumnForcedProps);
      column = chains(column);
  
      this.columnConfig = column;
  
      // 注册 watcher
      this.registerNormalWatchers();
      this.registerComplexWatchers();
    },
    mounted: function mounted() {
      var owner = this.owner;
      var parent = this.columnOrTableParent;
      var children = this.isSubColumn ? parent.$el.children : parent.$refs.hiddenColumns.children;
      var columnIndex = this.getColumnElIndex(children, this.$el);
      owner.store.commit('insertColumn', this.columnConfig, columnIndex, this.isSubColumn ? parent.columnConfig : null);
    },
    destroyed: function destroyed() {
      if (!this.$parent) return;
      var parent = this.$parent;
      this.owner.store.commit('removeColumn', this.columnConfig, this.isSubColumn ? parent.columnConfig : null);
    },
    render: function render(h) {
      // slots 也要渲染，需要计算合并表头
      return h('div', this.$slots.default);
    }
  });
  // CONCATENATED MODULE: ./packages/pl-table-column/index.js
  
  
  /* istanbul ignore next */
  table_column.install = function (Vue) {
    Vue.component(table_column.name, table_column);
  };
  
  /* harmony default export */ var pl_table_column = __webpack_exports__["default"] = (table_column);
  
  /***/ }),
  
  /***/ 3:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return normalizeComponent; });
  /* globals __VUE_SSR_CONTEXT__ */
  
  // IMPORTANT: Do NOT use ES2015 features in this file (except for modules).
  // This module is a runtime utility for cleaner component module output and will
  // be included in the final webpack user bundle.
  
  function normalizeComponent (
    scriptExports,
    render,
    staticRenderFns,
    functionalTemplate,
    injectStyles,
    scopeId,
    moduleIdentifier, /* server only */
    shadowMode /* vue-cli only */
  ) {
    // Vue.extend constructor export interop
    var options = typeof scriptExports === 'function'
      ? scriptExports.options
      : scriptExports
  
    // render functions
    if (render) {
      options.render = render
      options.staticRenderFns = staticRenderFns
      options._compiled = true
    }
  
    // functional template
    if (functionalTemplate) {
      options.functional = true
    }
  
    // scopedId
    if (scopeId) {
      options._scopeId = 'data-v-' + 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 = shadowMode
        ? function () { injectStyles.call(this, this.$root.$options.shadowRoot) }
        : injectStyles
    }
  
    if (hook) {
      if (options.functional) {
        // 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
        var originalRender = options.render
        options.render = function renderWithStyleInjection (h, context) {
          hook.call(context)
          return originalRender(h, context)
        }
      } else {
        // inject component registration as beforeCreate hook
        var existing = options.beforeCreate
        options.beforeCreate = existing
          ? [].concat(existing, hook)
          : [hook]
      }
    }
  
    return {
      exports: scriptExports,
      options: options
    }
  }
  
  
  /***/ }),
  
  /***/ 5:
  /***/ (function(module, exports) {
  
  module.exports = require("pl-table/lib/mixins/emitter");
  
  /***/ }),
  
  /***/ 6:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  
  // CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./packages/checkbox/src/checkbox.vue?vue&type=template&id=d0387074&
  var render = function() {
    var _vm = this
    var _h = _vm.$createElement
    var _c = _vm._self._c || _h
    return _c(
      "label",
      {
        staticClass: "el-checkbox",
        class: [
          _vm.border && _vm.checkboxSize
            ? "el-checkbox--" + _vm.checkboxSize
            : "",
          { "is-disabled": _vm.isDisabled },
          { "is-bordered": _vm.border },
          { "is-checked": _vm.isChecked }
        ],
        attrs: { id: _vm.id }
      },
      [
        _c(
          "span",
          {
            staticClass: "el-checkbox__input",
            class: {
              "is-disabled": _vm.isDisabled,
              "is-checked": _vm.isChecked,
              "is-indeterminate": _vm.indeterminate,
              "is-focus": _vm.focus
            },
            attrs: {
              tabindex: _vm.indeterminate ? 0 : false,
              role: _vm.indeterminate ? "checkbox" : false,
              "aria-checked": _vm.indeterminate ? "mixed" : false
            }
          },
          [
            _c("span", { staticClass: "el-checkbox__inner" }),
            _vm.trueLabel || _vm.falseLabel
              ? _c("input", {
                  directives: [
                    {
                      name: "model",
                      rawName: "v-model",
                      value: _vm.model,
                      expression: "model"
                    }
                  ],
                  staticClass: "el-checkbox__original",
                  attrs: {
                    type: "checkbox",
                    "aria-hidden": _vm.indeterminate ? "true" : "false",
                    name: _vm.name,
                    disabled: _vm.isDisabled,
                    "true-value": _vm.trueLabel,
                    "false-value": _vm.falseLabel
                  },
                  domProps: {
                    checked: Array.isArray(_vm.model)
                      ? _vm._i(_vm.model, null) > -1
                      : _vm._q(_vm.model, _vm.trueLabel)
                  },
                  on: {
                    change: [
                      function($event) {
                        var $$a = _vm.model,
                          $$el = $event.target,
                          $$c = $$el.checked ? _vm.trueLabel : _vm.falseLabel
                        if (Array.isArray($$a)) {
                          var $$v = null,
                            $$i = _vm._i($$a, $$v)
                          if ($$el.checked) {
                            $$i < 0 && (_vm.model = $$a.concat([$$v]))
                          } else {
                            $$i > -1 &&
                              (_vm.model = $$a
                                .slice(0, $$i)
                                .concat($$a.slice($$i + 1)))
                          }
                        } else {
                          _vm.model = $$c
                        }
                      },
                      _vm.handleChange
                    ],
                    focus: function($event) {
                      _vm.focus = true
                    },
                    blur: function($event) {
                      _vm.focus = false
                    }
                  }
                })
              : _c("input", {
                  directives: [
                    {
                      name: "model",
                      rawName: "v-model",
                      value: _vm.model,
                      expression: "model"
                    }
                  ],
                  staticClass: "el-checkbox__original",
                  attrs: {
                    type: "checkbox",
                    "aria-hidden": _vm.indeterminate ? "true" : "false",
                    disabled: _vm.isDisabled,
                    name: _vm.name
                  },
                  domProps: {
                    value: _vm.label,
                    checked: Array.isArray(_vm.model)
                      ? _vm._i(_vm.model, _vm.label) > -1
                      : _vm.model
                  },
                  on: {
                    change: [
                      function($event) {
                        var $$a = _vm.model,
                          $$el = $event.target,
                          $$c = $$el.checked ? true : false
                        if (Array.isArray($$a)) {
                          var $$v = _vm.label,
                            $$i = _vm._i($$a, $$v)
                          if ($$el.checked) {
                            $$i < 0 && (_vm.model = $$a.concat([$$v]))
                          } else {
                            $$i > -1 &&
                              (_vm.model = $$a
                                .slice(0, $$i)
                                .concat($$a.slice($$i + 1)))
                          }
                        } else {
                          _vm.model = $$c
                        }
                      },
                      _vm.handleChange
                    ],
                    focus: function($event) {
                      _vm.focus = true
                    },
                    blur: function($event) {
                      _vm.focus = false
                    }
                  }
                })
          ]
        ),
        _vm.$slots.default || _vm.label
          ? _c(
              "span",
              { staticClass: "el-checkbox__label" },
              [
                _vm._t("default"),
                !_vm.$slots.default ? [_vm._v(_vm._s(_vm.label))] : _vm._e()
              ],
              2
            )
          : _vm._e()
      ]
    )
  }
  var staticRenderFns = []
  render._withStripped = true
  
  
  // CONCATENATED MODULE: ./packages/checkbox/src/checkbox.vue?vue&type=template&id=d0387074&
  
  // EXTERNAL MODULE: external "pl-table/lib/mixins/emitter"
  var emitter_ = __webpack_require__(5);
  var emitter_default = /*#__PURE__*/__webpack_require__.n(emitter_);
  
  // CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./packages/checkbox/src/checkbox.vue?vue&type=script&lang=js&
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  
  
  
  /* harmony default export */ var checkboxvue_type_script_lang_js_ = ({
    name: 'ElCheckbox',
  
    mixins: [emitter_default.a],
  
    inject: {
      elForm: {
        default: ''
      },
      elFormItem: {
        default: ''
      }
    },
  
    componentName: 'ElCheckbox',
  
    data: function data() {
      return {
        selfModel: false,
        focus: false,
        isLimitExceeded: false
      };
    },
  
  
    computed: {
      model: {
        get: function get() {
          return this.isGroup ? this.store : this.value !== undefined ? this.value : this.selfModel;
        },
        set: function set(val) {
          if (this.isGroup) {
            this.isLimitExceeded = false;
            this._checkboxGroup.min !== undefined && val.length < this._checkboxGroup.min && (this.isLimitExceeded = true);
  
            this._checkboxGroup.max !== undefined && val.length > this._checkboxGroup.max && (this.isLimitExceeded = true);
  
            this.isLimitExceeded === false && this.dispatch('ElCheckboxGroup', 'input', [val]);
          } else {
            this.$emit('input', val);
            this.selfModel = val;
          }
        }
      },
  
      isChecked: function isChecked() {
        if ({}.toString.call(this.model) === '[object Boolean]') {
          return this.model;
        } else if (Array.isArray(this.model)) {
          return this.model.indexOf(this.label) > -1;
        } else if (this.model !== null && this.model !== undefined) {
          return this.model === this.trueLabel;
        }
      },
      isGroup: function isGroup() {
        var parent = this.$parent;
        while (parent) {
          if (parent.$options.componentName !== 'ElCheckboxGroup') {
            parent = parent.$parent;
          } else {
            this._checkboxGroup = parent;
            return true;
          }
        }
        return false;
      },
      store: function store() {
        return this._checkboxGroup ? this._checkboxGroup.value : this.value;
      },
  
  
      /* used to make the isDisabled judgment under max/min props */
      isLimitDisabled: function isLimitDisabled() {
        var _checkboxGroup = this._checkboxGroup,
            max = _checkboxGroup.max,
            min = _checkboxGroup.min;
  
        return !!(max || min) && this.model.length >= max && !this.isChecked || this.model.length <= min && this.isChecked;
      },
      isDisabled: function isDisabled() {
        return this.isGroup ? this._checkboxGroup.disabled || this.disabled || (this.elForm || {}).disabled || this.isLimitDisabled : this.disabled || (this.elForm || {}).disabled;
      },
      _elFormItemSize: function _elFormItemSize() {
        return (this.elFormItem || {}).elFormItemSize;
      },
      checkboxSize: function checkboxSize() {
        var temCheckboxSize = this.size || this._elFormItemSize || (this.$ELEMENT || {}).size;
        return this.isGroup ? this._checkboxGroup.checkboxGroupSize || temCheckboxSize : temCheckboxSize;
      }
    },
  
    props: {
      value: {},
      label: {},
      indeterminate: Boolean,
      disabled: Boolean,
      checked: Boolean,
      name: String,
      trueLabel: [String, Number],
      falseLabel: [String, Number],
      id: String, /* 当indeterminate为真时，为controls提供相关连的checkbox的id，表明元素间的控制关系*/
      controls: String, /* 当indeterminate为真时，为controls提供相关连的checkbox的id，表明元素间的控制关系*/
      border: Boolean,
      size: String
    },
  
    methods: {
      addToStore: function addToStore() {
        if (Array.isArray(this.model) && this.model.indexOf(this.label) === -1) {
          this.model.push(this.label);
        } else {
          this.model = this.trueLabel || true;
        }
      },
      handleChange: function handleChange(ev) {
        var _this = this;
  
        if (this.isLimitExceeded) return;
        var value = void 0;
        if (ev.target.checked) {
          value = this.trueLabel === undefined ? true : this.trueLabel;
        } else {
          value = this.falseLabel === undefined ? false : this.falseLabel;
        }
        this.$emit('change', value, ev);
        this.$nextTick(function () {
          if (_this.isGroup) {
            _this.dispatch('ElCheckboxGroup', 'change', [_this._checkboxGroup.value]);
          }
        });
      }
    },
  
    created: function created() {
      this.checked && this.addToStore();
    },
    mounted: function mounted() {
      // 为indeterminate元素 添加aria-controls 属性
      if (this.indeterminate) {
        this.$el.setAttribute('aria-controls', this.controls);
      }
    },
  
  
    watch: {
      value: function value(_value) {
        this.dispatch('ElFormItem', 'el.form.change', _value);
      }
    }
  });
  // CONCATENATED MODULE: ./packages/checkbox/src/checkbox.vue?vue&type=script&lang=js&
   /* harmony default export */ var src_checkboxvue_type_script_lang_js_ = (checkboxvue_type_script_lang_js_); 
  // EXTERNAL MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js
  var componentNormalizer = __webpack_require__(3);
  
  // CONCATENATED MODULE: ./packages/checkbox/src/checkbox.vue
  
  
  
  
  
  /* normalize component */
  
  var component = Object(componentNormalizer["a" /* default */])(
    src_checkboxvue_type_script_lang_js_,
    render,
    staticRenderFns,
    false,
    null,
    null,
    null
    
  )
  
  /* hot reload */
  if (false) { var api; }
  component.options.__file = "packages/checkbox/src/checkbox.vue"
  /* harmony default export */ var src_checkbox = (component.exports);
  // CONCATENATED MODULE: ./packages/checkbox/index.js
  
  
  /* istanbul ignore next */
  src_checkbox.install = function (Vue) {
    Vue.component(src_checkbox.name, src_checkbox);
  };
  
  /* harmony default export */ var packages_checkbox = __webpack_exports__["a"] = (src_checkbox);
  
  /***/ })
  
  /******/ });