V1

node_modules/vuetify/es5/components/VDataTable/MobileRow.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _vue = _interopRequireDefault(require("vue"));
+
+var _helpers = require("../../util/helpers");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var _default = _vue.default.extend({
+  name: 'row',
+  functional: true,
+  props: {
+    headers: Array,
+    item: Object,
+    rtl: Boolean
+  },
+  render: function render(h, _ref) {
+    var props = _ref.props,
+        slots = _ref.slots,
+        data = _ref.data;
+    var computedSlots = slots();
+    var columns = props.headers.map(function (header) {
+      var classes = {
+        'v-data-table__mobile-row': true
+      };
+      var children = [];
+      var value = (0, _helpers.getObjectValueByPath)(props.item, header.value);
+      var slotName = header.value;
+      var scopedSlot = data.scopedSlots && data.scopedSlots[slotName];
+      var regularSlot = computedSlots[slotName];
+
+      if (scopedSlot) {
+        children.push(scopedSlot({
+          item: props.item,
+          header: header,
+          value: value
+        }));
+      } else if (regularSlot) {
+        children.push(regularSlot);
+      } else {
+        children.push(value == null ? value : String(value));
+      }
+
+      var mobileRowChildren = [h('div', {
+        staticClass: 'v-data-table__mobile-row__cell'
+      }, children)];
+
+      if (header.value !== 'dataTableSelect') {
+        mobileRowChildren.unshift(h('div', {
+          staticClass: 'v-data-table__mobile-row__header'
+        }, [header.text]));
+      }
+
+      return h('td', {
+        class: classes
+      }, mobileRowChildren);
+    });
+    return h('tr', _objectSpread({}, data, {
+      staticClass: 'v-data-table__mobile-table-row'
+    }), columns);
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=MobileRow.js.map

node_modules/vuetify/es5/components/VDataTable/MobileRow.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VDataTable/MobileRow.ts"],"names":[],"mappings":";;;;;;;AAAA;;AACA;;;;;;;;;;eAGe,aAAI,MAAJ,CAAW;AACxB,EAAA,IAAI,EAAE,KADkB;AAGxB,EAAA,UAAU,EAAE,IAHY;AAKxB,EAAA,KAAK,EAAE;AACL,IAAA,OAAO,EAAE,KADJ;AAEL,IAAA,IAAI,EAAE,MAFD;AAGL,IAAA,GAAG,EAAE;AAHA,GALiB;AAWxB,EAAA,MAXwB,kBAWhB,CAXgB,QAWS;AAAA,QAApB,KAAoB,QAApB,KAAoB;AAAA,QAAb,KAAa,QAAb,KAAa;AAAA,QAAN,IAAM,QAAN,IAAM;AAC/B,QAAM,aAAa,GAAG,KAAK,EAA3B;AAEA,QAAM,OAAO,GAAY,KAAK,CAAC,OAAN,CAAc,GAAd,CAAkB,UAAC,MAAD,EAA4B;AACrE,UAAM,OAAO,GAAG;AACd,oCAA4B;AADd,OAAhB;AAIA,UAAM,QAAQ,GAAG,EAAjB;AACA,UAAM,KAAK,GAAG,mCAAqB,KAAK,CAAC,IAA3B,EAAiC,MAAM,CAAC,KAAxC,CAAd;AAEA,UAAM,QAAQ,GAAG,MAAM,CAAC,KAAxB;AACA,UAAM,UAAU,GAAG,IAAI,CAAC,WAAL,IAAoB,IAAI,CAAC,WAAL,CAAiB,QAAjB,CAAvC;AACA,UAAM,WAAW,GAAG,aAAa,CAAC,QAAD,CAAjC;;AAEA,UAAI,UAAJ,EAAgB;AACd,QAAA,QAAQ,CAAC,IAAT,CAAc,UAAU,CAAC;AAAE,UAAA,IAAI,EAAE,KAAK,CAAC,IAAd;AAAoB,UAAA,MAAM,EAAN,MAApB;AAA4B,UAAA,KAAK,EAAL;AAA5B,SAAD,CAAxB;AACD,OAFD,MAEO,IAAI,WAAJ,EAAiB;AACtB,QAAA,QAAQ,CAAC,IAAT,CAAc,WAAd;AACD,OAFM,MAEA;AACL,QAAA,QAAQ,CAAC,IAAT,CAAc,KAAK,IAAI,IAAT,GAAgB,KAAhB,GAAwB,MAAM,CAAC,KAAD,CAA5C;AACD;;AAED,UAAM,iBAAiB,GAAG,CACxB,CAAC,CAAC,KAAD,EAAQ;AACP,QAAA,WAAW,EAAE;AADN,OAAR,EAEE,QAFF,CADuB,CAA1B;;AAMA,UAAI,MAAM,CAAC,KAAP,KAAiB,iBAArB,EAAwC;AACtC,QAAA,iBAAiB,CAAC,OAAlB,CACE,CAAC,CAAC,KAAD,EAAQ;AACP,UAAA,WAAW,EAAE;AADN,SAAR,EAEE,CAAC,MAAM,CAAC,IAAR,CAFF,CADH;AAKD;;AAED,aAAO,CAAC,CAAC,IAAD,EAAO;AAAE,QAAA,KAAK,EAAE;AAAT,OAAP,EAA2B,iBAA3B,CAAR;AACD,KAnCwB,CAAzB;AAqCA,WAAO,CAAC,CAAC,IAAD,oBAAY,IAAZ;AAAkB,MAAA,WAAW,EAAE;AAA/B,QAAmE,OAAnE,CAAR;AACD;AApDuB,CAAX,C","sourcesContent":["import Vue, { VNode, PropType } from 'vue'\nimport { getObjectValueByPath } from '../../util/helpers'\nimport { DataTableHeader } from 'vuetify/types'\n\nexport default Vue.extend({\n  name: 'row',\n\n  functional: true,\n\n  props: {\n    headers: Array as PropType<DataTableHeader[]>,\n    item: Object,\n    rtl: Boolean,\n  },\n\n  render (h, { props, slots, data }): VNode {\n    const computedSlots = slots()\n\n    const columns: VNode[] = props.headers.map((header: DataTableHeader) => {\n      const classes = {\n        'v-data-table__mobile-row': true,\n      }\n\n      const children = []\n      const value = getObjectValueByPath(props.item, header.value)\n\n      const slotName = header.value\n      const scopedSlot = data.scopedSlots && data.scopedSlots[slotName]\n      const regularSlot = computedSlots[slotName]\n\n      if (scopedSlot) {\n        children.push(scopedSlot({ item: props.item, header, value }))\n      } else if (regularSlot) {\n        children.push(regularSlot)\n      } else {\n        children.push(value == null ? value : String(value))\n      }\n\n      const mobileRowChildren = [\n        h('div', {\n          staticClass: 'v-data-table__mobile-row__cell',\n        }, children),\n      ]\n\n      if (header.value !== 'dataTableSelect') {\n        mobileRowChildren.unshift(\n          h('div', {\n            staticClass: 'v-data-table__mobile-row__header',\n          }, [header.text])\n        )\n      }\n\n      return h('td', { class: classes }, mobileRowChildren)\n    })\n\n    return h('tr', { ...data, staticClass: 'v-data-table__mobile-table-row' }, columns)\n  },\n})\n"],"sourceRoot":"","file":"MobileRow.js"}

node_modules/vuetify/es5/components/VDataTable/Row.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _vue = _interopRequireDefault(require("vue"));
+
+var _helpers = require("../../util/helpers");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var _default = _vue.default.extend({
+  name: 'row',
+  functional: true,
+  props: {
+    headers: Array,
+    item: Object,
+    rtl: Boolean
+  },
+  render: function render(h, _ref) {
+    var props = _ref.props,
+        slots = _ref.slots,
+        data = _ref.data;
+    var computedSlots = slots();
+    var columns = props.headers.map(function (header) {
+      var _class;
+
+      var children = [];
+      var value = (0, _helpers.getObjectValueByPath)(props.item, header.value);
+      var slotName = header.value;
+      var scopedSlot = data.scopedSlots && data.scopedSlots[slotName];
+      var regularSlot = computedSlots[slotName];
+
+      if (scopedSlot) {
+        children.push(scopedSlot({
+          item: props.item,
+          header: header,
+          value: value
+        }));
+      } else if (regularSlot) {
+        children.push(regularSlot);
+      } else {
+        children.push(value == null ? value : String(value));
+      }
+
+      var textAlign = "text-".concat(header.align || 'start');
+      return h('td', {
+        class: (_class = {}, _defineProperty(_class, textAlign, true), _defineProperty(_class, 'v-data-table__divider', header.divider), _class)
+      }, children);
+    });
+    return h('tr', data, columns);
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=Row.js.map

node_modules/vuetify/es5/components/VDataTable/Row.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VDataTable/Row.ts"],"names":[],"mappings":";;;;;;;AACA;;AAIA;;;;;;eAEe,aAAI,MAAJ,CAAW;AACxB,EAAA,IAAI,EAAE,KADkB;AAGxB,EAAA,UAAU,EAAE,IAHY;AAKxB,EAAA,KAAK,EAAE;AACL,IAAA,OAAO,EAAE,KADJ;AAEL,IAAA,IAAI,EAAE,MAFD;AAGL,IAAA,GAAG,EAAE;AAHA,GALiB;AAWxB,EAAA,MAXwB,kBAWhB,CAXgB,QAWS;AAAA,QAApB,KAAoB,QAApB,KAAoB;AAAA,QAAb,KAAa,QAAb,KAAa;AAAA,QAAN,IAAM,QAAN,IAAM;AAC/B,QAAM,aAAa,GAAG,KAAK,EAA3B;AAEA,QAAM,OAAO,GAAY,KAAK,CAAC,OAAN,CAAc,GAAd,CAAkB,UAAC,MAAD,EAA4B;AAAA;;AACrE,UAAM,QAAQ,GAAG,EAAjB;AACA,UAAM,KAAK,GAAG,mCAAqB,KAAK,CAAC,IAA3B,EAAiC,MAAM,CAAC,KAAxC,CAAd;AAEA,UAAM,QAAQ,GAAG,MAAM,CAAC,KAAxB;AACA,UAAM,UAAU,GAAG,IAAI,CAAC,WAAL,IAAoB,IAAI,CAAC,WAAL,CAAiB,QAAjB,CAAvC;AACA,UAAM,WAAW,GAAG,aAAa,CAAC,QAAD,CAAjC;;AAEA,UAAI,UAAJ,EAAgB;AACd,QAAA,QAAQ,CAAC,IAAT,CAAc,UAAU,CAAC;AAAE,UAAA,IAAI,EAAE,KAAK,CAAC,IAAd;AAAoB,UAAA,MAAM,EAAN,MAApB;AAA4B,UAAA,KAAK,EAAL;AAA5B,SAAD,CAAxB;AACD,OAFD,MAEO,IAAI,WAAJ,EAAiB;AACtB,QAAA,QAAQ,CAAC,IAAT,CAAc,WAAd;AACD,OAFM,MAEA;AACL,QAAA,QAAQ,CAAC,IAAT,CAAc,KAAK,IAAI,IAAT,GAAgB,KAAhB,GAAwB,MAAM,CAAC,KAAD,CAA5C;AACD;;AAED,UAAM,SAAS,kBAAW,MAAM,CAAC,KAAP,IAAgB,OAA3B,CAAf;AAEA,aAAO,CAAC,CAAC,IAAD,EAAO;AACb,QAAA,KAAK,wCACF,SADE,EACU,IADV,2BAEH,uBAFG,EAEsB,MAAM,CAAC,OAF7B;AADQ,OAAP,EAKL,QALK,CAAR;AAMD,KAxBwB,CAAzB;AA0BA,WAAO,CAAC,CAAC,IAAD,EAAO,IAAP,EAAa,OAAb,CAAR;AACD;AAzCuB,CAAX,C","sourcesContent":["// Types\nimport Vue, { VNode, PropType } from 'vue'\nimport { DataTableHeader } from 'vuetify/types'\n\n// Utils\nimport { getObjectValueByPath } from '../../util/helpers'\n\nexport default Vue.extend({\n  name: 'row',\n\n  functional: true,\n\n  props: {\n    headers: Array as PropType<DataTableHeader[]>,\n    item: Object,\n    rtl: Boolean,\n  },\n\n  render (h, { props, slots, data }): VNode {\n    const computedSlots = slots()\n\n    const columns: VNode[] = props.headers.map((header: DataTableHeader) => {\n      const children = []\n      const value = getObjectValueByPath(props.item, header.value)\n\n      const slotName = header.value\n      const scopedSlot = data.scopedSlots && data.scopedSlots[slotName]\n      const regularSlot = computedSlots[slotName]\n\n      if (scopedSlot) {\n        children.push(scopedSlot({ item: props.item, header, value }))\n      } else if (regularSlot) {\n        children.push(regularSlot)\n      } else {\n        children.push(value == null ? value : String(value))\n      }\n\n      const textAlign = `text-${header.align || 'start'}`\n\n      return h('td', {\n        class: {\n          [textAlign]: true,\n          'v-data-table__divider': header.divider,\n        },\n      }, children)\n    })\n\n    return h('tr', data, columns)\n  },\n})\n"],"sourceRoot":"","file":"Row.js"}

node_modules/vuetify/es5/components/VDataTable/RowGroup.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _vue = _interopRequireDefault(require("vue"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
+
+function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
+
+var _default = _vue.default.extend({
+  name: 'row-group',
+  functional: true,
+  props: {
+    value: {
+      type: Boolean,
+      default: true
+    },
+    headerClass: {
+      type: String,
+      default: 'v-row-group__header'
+    },
+    contentClass: String,
+    summaryClass: {
+      type: String,
+      default: 'v-row-group__summary'
+    }
+  },
+  render: function render(h, _ref) {
+    var slots = _ref.slots,
+        props = _ref.props;
+    var computedSlots = slots();
+    var children = [];
+
+    if (computedSlots['column.header']) {
+      children.push(h('tr', {
+        staticClass: props.headerClass
+      }, computedSlots['column.header']));
+    } else if (computedSlots['row.header']) {
+      children.push.apply(children, _toConsumableArray(computedSlots['row.header']));
+    }
+
+    if (computedSlots['row.content'] && props.value) children.push.apply(children, _toConsumableArray(computedSlots['row.content']));
+
+    if (computedSlots['column.summary']) {
+      children.push(h('tr', {
+        staticClass: props.summaryClass
+      }, computedSlots['column.summary']));
+    } else if (computedSlots['row.summary']) {
+      children.push.apply(children, _toConsumableArray(computedSlots['row.summary']));
+    }
+
+    return children;
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=RowGroup.js.map

node_modules/vuetify/es5/components/VDataTable/RowGroup.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VDataTable/RowGroup.ts"],"names":[],"mappings":";;;;;;;AAAA;;;;;;;;;;;;eAEe,aAAI,MAAJ,CAAW;AACxB,EAAA,IAAI,EAAE,WADkB;AAGxB,EAAA,UAAU,EAAE,IAHY;AAKxB,EAAA,KAAK,EAAE;AACL,IAAA,KAAK,EAAE;AACL,MAAA,IAAI,EAAE,OADD;AAEL,MAAA,OAAO,EAAE;AAFJ,KADF;AAKL,IAAA,WAAW,EAAE;AACX,MAAA,IAAI,EAAE,MADK;AAEX,MAAA,OAAO,EAAE;AAFE,KALR;AASL,IAAA,YAAY,EAAE,MATT;AAUL,IAAA,YAAY,EAAE;AACZ,MAAA,IAAI,EAAE,MADM;AAEZ,MAAA,OAAO,EAAE;AAFG;AAVT,GALiB;AAqBxB,EAAA,MArBwB,kBAqBhB,CArBgB,QAqBG;AAAA,QAAd,KAAc,QAAd,KAAc;AAAA,QAAP,KAAO,QAAP,KAAO;AACzB,QAAM,aAAa,GAAG,KAAK,EAA3B;AACA,QAAM,QAAQ,GAAG,EAAjB;;AAEA,QAAI,aAAa,CAAC,eAAD,CAAjB,EAAoC;AAClC,MAAA,QAAQ,CAAC,IAAT,CAAc,CAAC,CAAC,IAAD,EAAO;AACpB,QAAA,WAAW,EAAE,KAAK,CAAC;AADC,OAAP,EAEZ,aAAa,CAAC,eAAD,CAFD,CAAf;AAGD,KAJD,MAIO,IAAI,aAAa,CAAC,YAAD,CAAjB,EAAiC;AACtC,MAAA,QAAQ,CAAC,IAAT,OAAA,QAAQ,qBAAS,aAAa,CAAC,YAAD,CAAtB,EAAR;AACD;;AAED,QAAI,aAAa,CAAC,aAAD,CAAb,IAAgC,KAAK,CAAC,KAA1C,EAAiD,QAAQ,CAAC,IAAT,OAAA,QAAQ,qBAAS,aAAa,CAAC,aAAD,CAAtB,EAAR;;AAEjD,QAAI,aAAa,CAAC,gBAAD,CAAjB,EAAqC;AACnC,MAAA,QAAQ,CAAC,IAAT,CAAc,CAAC,CAAC,IAAD,EAAO;AACpB,QAAA,WAAW,EAAE,KAAK,CAAC;AADC,OAAP,EAEZ,aAAa,CAAC,gBAAD,CAFD,CAAf;AAGD,KAJD,MAIO,IAAI,aAAa,CAAC,aAAD,CAAjB,EAAkC;AACvC,MAAA,QAAQ,CAAC,IAAT,OAAA,QAAQ,qBAAS,aAAa,CAAC,aAAD,CAAtB,EAAR;AACD;;AAED,WAAO,QAAP;AACD;AA5CuB,CAAX,C","sourcesContent":["import Vue, { VNode } from 'vue'\n\nexport default Vue.extend({\n  name: 'row-group',\n\n  functional: true,\n\n  props: {\n    value: {\n      type: Boolean,\n      default: true,\n    },\n    headerClass: {\n      type: String,\n      default: 'v-row-group__header',\n    },\n    contentClass: String,\n    summaryClass: {\n      type: String,\n      default: 'v-row-group__summary',\n    },\n  },\n\n  render (h, { slots, props }): VNode {\n    const computedSlots = slots()\n    const children = []\n\n    if (computedSlots['column.header']) {\n      children.push(h('tr', {\n        staticClass: props.headerClass,\n      }, computedSlots['column.header']))\n    } else if (computedSlots['row.header']) {\n      children.push(...computedSlots['row.header'])\n    }\n\n    if (computedSlots['row.content'] && props.value) children.push(...computedSlots['row.content'])\n\n    if (computedSlots['column.summary']) {\n      children.push(h('tr', {\n        staticClass: props.summaryClass,\n      }, computedSlots['column.summary']))\n    } else if (computedSlots['row.summary']) {\n      children.push(...computedSlots['row.summary'])\n    }\n\n    return children as any\n  },\n})\n"],"sourceRoot":"","file":"RowGroup.js"}

node_modules/vuetify/es5/components/VDataTable/VDataTable.js

@@ -0,0 +1,675 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("../../../src/components/VDataTable/VDataTable.sass");
+
+var _VData = require("../VData");
+
+var _VDataIterator = require("../VDataIterator");
+
+var _VBtn = _interopRequireDefault(require("../VBtn"));
+
+var _VDataTableHeader = _interopRequireDefault(require("./VDataTableHeader"));
+
+var _VIcon = _interopRequireDefault(require("../VIcon"));
+
+var _Row = _interopRequireDefault(require("./Row"));
+
+var _RowGroup = _interopRequireDefault(require("./RowGroup"));
+
+var _VSimpleCheckbox = _interopRequireDefault(require("../VCheckbox/VSimpleCheckbox"));
+
+var _VSimpleTable = _interopRequireDefault(require("./VSimpleTable"));
+
+var _MobileRow = _interopRequireDefault(require("./MobileRow"));
+
+var _loadable = _interopRequireDefault(require("../../mixins/loadable"));
+
+var _ripple = _interopRequireDefault(require("../../directives/ripple"));
+
+var _mixins = _interopRequireDefault(require("../../util/mixins"));
+
+var _helpers = require("../../util/helpers");
+
+var _console = require("../../util/console");
+
+var _mergeData = require("../../util/mergeData");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
+
+function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function filterFn(item, search, filter) {
+  return function (header) {
+    var value = (0, _helpers.getObjectValueByPath)(item, header.value);
+    return header.filter ? header.filter(value, search, item) : filter(value, search, item);
+  };
+}
+
+function searchTableItems(items, search, headersWithCustomFilters, headersWithoutCustomFilters, customFilter) {
+  search = typeof search === 'string' ? search.trim() : null;
+  return items.filter(function (item) {
+    // Headers with custom filters are evaluated whether or not a search term has been provided.
+    // We need to match every filter to be included in the results.
+    var matchesColumnFilters = headersWithCustomFilters.every(filterFn(item, search, _helpers.defaultFilter)); // Headers without custom filters are only filtered by the `search` property if it is defined.
+    // We only need a single column to match the search term to be included in the results.
+
+    var matchesSearchTerm = !search || headersWithoutCustomFilters.some(filterFn(item, search, customFilter));
+    return matchesColumnFilters && matchesSearchTerm;
+  });
+}
+/* @vue/component */
+
+
+var _default2 = (0, _mixins.default)(_VDataIterator.VDataIterator, _loadable.default).extend({
+  name: 'v-data-table',
+  // https://github.com/vuejs/vue/issues/6872
+  directives: {
+    ripple: _ripple.default
+  },
+  props: {
+    headers: {
+      type: Array,
+      default: function _default() {
+        return [];
+      }
+    },
+    showSelect: Boolean,
+    showExpand: Boolean,
+    showGroupBy: Boolean,
+    // TODO: Fix
+    // virtualRows: Boolean,
+    height: [Number, String],
+    hideDefaultHeader: Boolean,
+    caption: String,
+    dense: Boolean,
+    headerProps: Object,
+    calculateWidths: Boolean,
+    fixedHeader: Boolean,
+    headersLength: Number,
+    expandIcon: {
+      type: String,
+      default: '$expand'
+    },
+    customFilter: {
+      type: Function,
+      default: _helpers.defaultFilter
+    },
+    itemClass: {
+      type: [String, Function],
+      default: function _default() {
+        return '';
+      }
+    },
+    loaderHeight: {
+      type: [Number, String],
+      default: 4
+    }
+  },
+  data: function data() {
+    return {
+      internalGroupBy: [],
+      openCache: {},
+      widths: []
+    };
+  },
+  computed: {
+    computedHeaders: function computedHeaders() {
+      var _this = this;
+
+      if (!this.headers) return [];
+      var headers = this.headers.filter(function (h) {
+        return h.value === undefined || !_this.internalGroupBy.find(function (v) {
+          return v === h.value;
+        });
+      });
+      var defaultHeader = {
+        text: '',
+        sortable: false,
+        width: '1px'
+      };
+
+      if (this.showSelect) {
+        var index = headers.findIndex(function (h) {
+          return h.value === 'data-table-select';
+        });
+        if (index < 0) headers.unshift(_objectSpread({}, defaultHeader, {
+          value: 'data-table-select'
+        }));else headers.splice(index, 1, _objectSpread({}, defaultHeader, {}, headers[index]));
+      }
+
+      if (this.showExpand) {
+        var _index = headers.findIndex(function (h) {
+          return h.value === 'data-table-expand';
+        });
+
+        if (_index < 0) headers.unshift(_objectSpread({}, defaultHeader, {
+          value: 'data-table-expand'
+        }));else headers.splice(_index, 1, _objectSpread({}, defaultHeader, {}, headers[_index]));
+      }
+
+      return headers;
+    },
+    colspanAttrs: function colspanAttrs() {
+      return this.isMobile ? undefined : {
+        colspan: this.headersLength || this.computedHeaders.length
+      };
+    },
+    columnSorters: function columnSorters() {
+      return this.computedHeaders.reduce(function (acc, header) {
+        if (header.sort) acc[header.value] = header.sort;
+        return acc;
+      }, {});
+    },
+    headersWithCustomFilters: function headersWithCustomFilters() {
+      return this.headers.filter(function (header) {
+        return header.filter && (!header.hasOwnProperty('filterable') || header.filterable === true);
+      });
+    },
+    headersWithoutCustomFilters: function headersWithoutCustomFilters() {
+      return this.headers.filter(function (header) {
+        return !header.filter && (!header.hasOwnProperty('filterable') || header.filterable === true);
+      });
+    },
+    sanitizedHeaderProps: function sanitizedHeaderProps() {
+      return (0, _helpers.camelizeObjectKeys)(this.headerProps);
+    },
+    computedItemsPerPage: function computedItemsPerPage() {
+      var itemsPerPage = this.options && this.options.itemsPerPage ? this.options.itemsPerPage : this.itemsPerPage;
+      var itemsPerPageOptions = this.sanitizedFooterProps.itemsPerPageOptions;
+
+      if (itemsPerPageOptions && !itemsPerPageOptions.find(function (item) {
+        return typeof item === 'number' ? item === itemsPerPage : item.value === itemsPerPage;
+      })) {
+        var firstOption = itemsPerPageOptions[0];
+        return _typeof(firstOption) === 'object' ? firstOption.value : firstOption;
+      }
+
+      return itemsPerPage;
+    }
+  },
+  created: function created() {
+    var _this2 = this;
+
+    var breakingProps = [['sort-icon', 'header-props.sort-icon'], ['hide-headers', 'hide-default-header'], ['select-all', 'show-select']];
+    /* istanbul ignore next */
+
+    breakingProps.forEach(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+          original = _ref2[0],
+          replacement = _ref2[1];
+
+      if (_this2.$attrs.hasOwnProperty(original)) (0, _console.breaking)(original, replacement, _this2);
+    });
+  },
+  mounted: function mounted() {
+    // if ((!this.sortBy || !this.sortBy.length) && (!this.options.sortBy || !this.options.sortBy.length)) {
+    //   const firstSortable = this.headers.find(h => !('sortable' in h) || !!h.sortable)
+    //   if (firstSortable) this.updateOptions({ sortBy: [firstSortable.value], sortDesc: [false] })
+    // }
+    if (this.calculateWidths) {
+      window.addEventListener('resize', this.calcWidths);
+      this.calcWidths();
+    }
+  },
+  beforeDestroy: function beforeDestroy() {
+    if (this.calculateWidths) {
+      window.removeEventListener('resize', this.calcWidths);
+    }
+  },
+  methods: {
+    calcWidths: function calcWidths() {
+      this.widths = Array.from(this.$el.querySelectorAll('th')).map(function (e) {
+        return e.clientWidth;
+      });
+    },
+    customFilterWithColumns: function customFilterWithColumns(items, search) {
+      return searchTableItems(items, search, this.headersWithCustomFilters, this.headersWithoutCustomFilters, this.customFilter);
+    },
+    customSortWithHeaders: function customSortWithHeaders(items, sortBy, sortDesc, locale) {
+      return this.customSort(items, sortBy, sortDesc, locale, this.columnSorters);
+    },
+    createItemProps: function createItemProps(item) {
+      var props = _VDataIterator.VDataIterator.options.methods.createItemProps.call(this, item);
+
+      return Object.assign(props, {
+        headers: this.computedHeaders
+      });
+    },
+    genCaption: function genCaption(props) {
+      if (this.caption) return [this.$createElement('caption', [this.caption])];
+      return (0, _helpers.getSlot)(this, 'caption', props, true);
+    },
+    genColgroup: function genColgroup(props) {
+      var _this3 = this;
+
+      return this.$createElement('colgroup', this.computedHeaders.map(function (header) {
+        return _this3.$createElement('col', {
+          class: {
+            divider: header.divider
+          }
+        });
+      }));
+    },
+    genLoading: function genLoading() {
+      var th = this.$createElement('th', {
+        staticClass: 'column',
+        attrs: this.colspanAttrs
+      }, [this.genProgress()]);
+      var tr = this.$createElement('tr', {
+        staticClass: 'v-data-table__progress'
+      }, [th]);
+      return this.$createElement('thead', [tr]);
+    },
+    genHeaders: function genHeaders(props) {
+      var data = {
+        props: _objectSpread({}, this.sanitizedHeaderProps, {
+          headers: this.computedHeaders,
+          options: props.options,
+          mobile: this.isMobile,
+          showGroupBy: this.showGroupBy,
+          someItems: this.someItems,
+          everyItem: this.everyItem,
+          singleSelect: this.singleSelect,
+          disableSort: this.disableSort
+        }),
+        on: {
+          sort: props.sort,
+          group: props.group,
+          'toggle-select-all': this.toggleSelectAll
+        }
+      };
+      var children = [(0, _helpers.getSlot)(this, 'header', data)];
+
+      if (!this.hideDefaultHeader) {
+        var scopedSlots = (0, _helpers.getPrefixedScopedSlots)('header.', this.$scopedSlots);
+        children.push(this.$createElement(_VDataTableHeader.default, _objectSpread({}, data, {
+          scopedSlots: scopedSlots
+        })));
+      }
+
+      if (this.loading) children.push(this.genLoading());
+      return children;
+    },
+    genEmptyWrapper: function genEmptyWrapper(content) {
+      return this.$createElement('tr', {
+        staticClass: 'v-data-table__empty-wrapper'
+      }, [this.$createElement('td', {
+        attrs: this.colspanAttrs
+      }, content)]);
+    },
+    genItems: function genItems(items, props) {
+      var empty = this.genEmpty(props.originalItemsLength, props.pagination.itemsLength);
+      if (empty) return [empty];
+      return props.groupedItems ? this.genGroupedRows(props.groupedItems, props) : this.genRows(items, props);
+    },
+    genGroupedRows: function genGroupedRows(groupedItems, props) {
+      var _this4 = this;
+
+      return groupedItems.map(function (group) {
+        if (!_this4.openCache.hasOwnProperty(group.name)) _this4.$set(_this4.openCache, group.name, true);
+
+        if (_this4.$scopedSlots.group) {
+          return _this4.$scopedSlots.group({
+            group: group.name,
+            options: props.options,
+            items: group.items,
+            headers: _this4.computedHeaders
+          });
+        } else {
+          return _this4.genDefaultGroupedRow(group.name, group.items, props);
+        }
+      });
+    },
+    genDefaultGroupedRow: function genDefaultGroupedRow(group, items, props) {
+      var _this5 = this;
+
+      var isOpen = !!this.openCache[group];
+      var children = [this.$createElement('template', {
+        slot: 'row.content'
+      }, this.genRows(items, props))];
+
+      var toggleFn = function toggleFn() {
+        return _this5.$set(_this5.openCache, group, !_this5.openCache[group]);
+      };
+
+      var removeFn = function removeFn() {
+        return props.updateOptions({
+          groupBy: [],
+          groupDesc: []
+        });
+      };
+
+      if (this.$scopedSlots['group.header']) {
+        children.unshift(this.$createElement('template', {
+          slot: 'column.header'
+        }, [this.$scopedSlots['group.header']({
+          group: group,
+          groupBy: props.options.groupBy,
+          items: items,
+          headers: this.computedHeaders,
+          isOpen: isOpen,
+          toggle: toggleFn,
+          remove: removeFn
+        })]));
+      } else {
+        var toggle = this.$createElement(_VBtn.default, {
+          staticClass: 'ma-0',
+          props: {
+            icon: true,
+            small: true
+          },
+          on: {
+            click: toggleFn
+          }
+        }, [this.$createElement(_VIcon.default, [isOpen ? '$minus' : '$plus'])]);
+        var remove = this.$createElement(_VBtn.default, {
+          staticClass: 'ma-0',
+          props: {
+            icon: true,
+            small: true
+          },
+          on: {
+            click: removeFn
+          }
+        }, [this.$createElement(_VIcon.default, ['$close'])]);
+        var column = this.$createElement('td', {
+          staticClass: 'text-start',
+          attrs: this.colspanAttrs
+        }, [toggle, "".concat(props.options.groupBy[0], ": ").concat(group), remove]);
+        children.unshift(this.$createElement('template', {
+          slot: 'column.header'
+        }, [column]));
+      }
+
+      if (this.$scopedSlots['group.summary']) {
+        children.push(this.$createElement('template', {
+          slot: 'column.summary'
+        }, [this.$scopedSlots['group.summary']({
+          group: group,
+          groupBy: props.options.groupBy,
+          items: items,
+          headers: this.computedHeaders,
+          isOpen: isOpen,
+          toggle: toggleFn
+        })]));
+      }
+
+      return this.$createElement(_RowGroup.default, {
+        key: group,
+        props: {
+          value: isOpen
+        }
+      }, children);
+    },
+    genRows: function genRows(items, props) {
+      return this.$scopedSlots.item ? this.genScopedRows(items, props) : this.genDefaultRows(items, props);
+    },
+    genScopedRows: function genScopedRows(items, props) {
+      var rows = [];
+
+      for (var i = 0; i < items.length; i++) {
+        var item = items[i];
+        rows.push(this.$scopedSlots.item(_objectSpread({}, this.createItemProps(item), {
+          index: i
+        })));
+
+        if (this.isExpanded(item)) {
+          rows.push(this.$scopedSlots['expanded-item']({
+            item: item,
+            headers: this.computedHeaders
+          }));
+        }
+      }
+
+      return rows;
+    },
+    genDefaultRows: function genDefaultRows(items, props) {
+      var _this6 = this;
+
+      return this.$scopedSlots['expanded-item'] ? items.map(function (item) {
+        return _this6.genDefaultExpandedRow(item);
+      }) : items.map(function (item) {
+        return _this6.genDefaultSimpleRow(item);
+      });
+    },
+    genDefaultExpandedRow: function genDefaultExpandedRow(item) {
+      var isExpanded = this.isExpanded(item);
+      var classes = {
+        'v-data-table__expanded v-data-table__expanded__row': isExpanded
+      };
+      var headerRow = this.genDefaultSimpleRow(item, classes);
+      var expandedRow = this.$createElement('tr', {
+        staticClass: 'v-data-table__expanded v-data-table__expanded__content'
+      }, [this.$scopedSlots['expanded-item']({
+        item: item,
+        headers: this.computedHeaders
+      })]);
+      return this.$createElement(_RowGroup.default, {
+        props: {
+          value: isExpanded
+        }
+      }, [this.$createElement('template', {
+        slot: 'row.header'
+      }, [headerRow]), this.$createElement('template', {
+        slot: 'row.content'
+      }, [expandedRow])]);
+    },
+    genDefaultSimpleRow: function genDefaultSimpleRow(item) {
+      var _this7 = this;
+
+      var classes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var scopedSlots = (0, _helpers.getPrefixedScopedSlots)('item.', this.$scopedSlots);
+      var data = this.createItemProps(item);
+
+      if (this.showSelect) {
+        var slot = scopedSlots['data-table-select'];
+        scopedSlots['data-table-select'] = slot ? function () {
+          return slot(data);
+        } : function () {
+          return _this7.$createElement(_VSimpleCheckbox.default, {
+            staticClass: 'v-data-table__checkbox',
+            props: {
+              value: data.isSelected,
+              disabled: !_this7.isSelectable(item)
+            },
+            on: {
+              input: function input(val) {
+                return data.select(val);
+              }
+            }
+          });
+        };
+      }
+
+      if (this.showExpand) {
+        var _slot = scopedSlots['data-table-expand'];
+        scopedSlots['data-table-expand'] = _slot ? function () {
+          return _slot(data);
+        } : function () {
+          return _this7.$createElement(_VIcon.default, {
+            staticClass: 'v-data-table__expand-icon',
+            class: {
+              'v-data-table__expand-icon--active': data.isExpanded
+            },
+            on: {
+              click: function click(e) {
+                e.stopPropagation();
+                data.expand(!data.isExpanded);
+              }
+            }
+          }, [_this7.expandIcon]);
+        };
+      }
+
+      return this.$createElement(this.isMobile ? _MobileRow.default : _Row.default, {
+        key: (0, _helpers.getObjectValueByPath)(item, this.itemKey),
+        class: (0, _mergeData.mergeClasses)(_objectSpread({}, classes, {
+          'v-data-table__selected': data.isSelected
+        }), (0, _helpers.getPropertyFromItem)(item, this.itemClass)),
+        props: {
+          headers: this.computedHeaders,
+          item: item,
+          rtl: this.$vuetify.rtl
+        },
+        scopedSlots: scopedSlots,
+        on: {
+          // TODO: for click, the first argument should be the event, and the second argument should be data,
+          // but this is a breaking change so it's for v3
+          click: function click() {
+            return _this7.$emit('click:row', item, data);
+          },
+          contextmenu: function contextmenu(event) {
+            return _this7.$emit('contextmenu:row', event, data);
+          },
+          dblclick: function dblclick(event) {
+            return _this7.$emit('dblclick:row', event, data);
+          }
+        }
+      });
+    },
+    genBody: function genBody(props) {
+      var data = _objectSpread({}, props, {
+        expand: this.expand,
+        headers: this.computedHeaders,
+        isExpanded: this.isExpanded,
+        isMobile: this.isMobile,
+        isSelected: this.isSelected,
+        select: this.select
+      });
+
+      if (this.$scopedSlots.body) {
+        return this.$scopedSlots.body(data);
+      }
+
+      return this.$createElement('tbody', [(0, _helpers.getSlot)(this, 'body.prepend', data, true), this.genItems(props.items, props), (0, _helpers.getSlot)(this, 'body.append', data, true)]);
+    },
+    genFooters: function genFooters(props) {
+      var data = {
+        props: _objectSpread({
+          options: props.options,
+          pagination: props.pagination,
+          itemsPerPageText: '$vuetify.dataTable.itemsPerPageText'
+        }, this.sanitizedFooterProps),
+        on: {
+          'update:options': function updateOptions(value) {
+            return props.updateOptions(value);
+          }
+        },
+        widths: this.widths,
+        headers: this.computedHeaders
+      };
+      var children = [(0, _helpers.getSlot)(this, 'footer', data, true)];
+
+      if (!this.hideDefaultFooter) {
+        children.push(this.$createElement(_VDataIterator.VDataFooter, _objectSpread({}, data, {
+          scopedSlots: (0, _helpers.getPrefixedScopedSlots)('footer.', this.$scopedSlots)
+        })));
+      }
+
+      return children;
+    },
+    genDefaultScopedSlot: function genDefaultScopedSlot(props) {
+      var simpleProps = {
+        height: this.height,
+        fixedHeader: this.fixedHeader,
+        dense: this.dense
+      }; // if (this.virtualRows) {
+      //   return this.$createElement(VVirtualTable, {
+      //     props: Object.assign(simpleProps, {
+      //       items: props.items,
+      //       height: this.height,
+      //       rowHeight: this.dense ? 24 : 48,
+      //       headerHeight: this.dense ? 32 : 48,
+      //       // TODO: expose rest of props from virtual table?
+      //     }),
+      //     scopedSlots: {
+      //       items: ({ items }) => this.genItems(items, props) as any,
+      //     },
+      //   }, [
+      //     this.proxySlot('body.before', [this.genCaption(props), this.genHeaders(props)]),
+      //     this.proxySlot('bottom', this.genFooters(props)),
+      //   ])
+      // }
+
+      return this.$createElement(_VSimpleTable.default, {
+        props: simpleProps
+      }, [this.proxySlot('top', (0, _helpers.getSlot)(this, 'top', props, true)), this.genCaption(props), this.genColgroup(props), this.genHeaders(props), this.genBody(props), this.proxySlot('bottom', this.genFooters(props))]);
+    },
+    proxySlot: function proxySlot(slot, content) {
+      return this.$createElement('template', {
+        slot: slot
+      }, content);
+    }
+  },
+  render: function render() {
+    var _this8 = this;
+
+    return this.$createElement(_VData.VData, {
+      props: _objectSpread({}, this.$props, {
+        customFilter: this.customFilterWithColumns,
+        customSort: this.customSortWithHeaders,
+        itemsPerPage: this.computedItemsPerPage
+      }),
+      on: {
+        'update:options': function updateOptions(v, old) {
+          _this8.internalGroupBy = v.groupBy || [];
+          !(0, _helpers.deepEqual)(v, old) && _this8.$emit('update:options', v);
+        },
+        'update:page': function updatePage(v) {
+          return _this8.$emit('update:page', v);
+        },
+        'update:items-per-page': function updateItemsPerPage(v) {
+          return _this8.$emit('update:items-per-page', v);
+        },
+        'update:sort-by': function updateSortBy(v) {
+          return _this8.$emit('update:sort-by', v);
+        },
+        'update:sort-desc': function updateSortDesc(v) {
+          return _this8.$emit('update:sort-desc', v);
+        },
+        'update:group-by': function updateGroupBy(v) {
+          return _this8.$emit('update:group-by', v);
+        },
+        'update:group-desc': function updateGroupDesc(v) {
+          return _this8.$emit('update:group-desc', v);
+        },
+        pagination: function pagination(v, old) {
+          return !(0, _helpers.deepEqual)(v, old) && _this8.$emit('pagination', v);
+        },
+        'current-items': function currentItems(v) {
+          _this8.internalCurrentItems = v;
+
+          _this8.$emit('current-items', v);
+        },
+        'page-count': function pageCount(v) {
+          return _this8.$emit('page-count', v);
+        }
+      },
+      scopedSlots: {
+        default: this.genDefaultScopedSlot
+      }
+    });
+  }
+});
+
+exports.default = _default2;
+//# sourceMappingURL=VDataTable.js.map

node_modules/vuetify/es5/components/VDataTable/VDataTableHeader.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("../../../src/components/VDataTable/VDataTableHeader.sass");
+
+var _VDataTableHeaderMobile = _interopRequireDefault(require("./VDataTableHeaderMobile"));
+
+var _VDataTableHeaderDesktop = _interopRequireDefault(require("./VDataTableHeaderDesktop"));
+
+var _header = _interopRequireDefault(require("./mixins/header"));
+
+var _dedupeModelListeners = _interopRequireDefault(require("../../util/dedupeModelListeners"));
+
+var _mergeData = _interopRequireDefault(require("../../util/mergeData"));
+
+var _rebuildFunctionalSlots = _interopRequireDefault(require("../../util/rebuildFunctionalSlots"));
+
+var _vue = _interopRequireDefault(require("vue"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/* @vue/component */
+var _default = _vue.default.extend({
+  name: 'v-data-table-header',
+  functional: true,
+  props: _objectSpread({}, _header.default.options.props, {
+    mobile: Boolean
+  }),
+  render: function render(h, _ref) {
+    var props = _ref.props,
+        data = _ref.data,
+        slots = _ref.slots;
+    (0, _dedupeModelListeners.default)(data);
+    var children = (0, _rebuildFunctionalSlots.default)(slots(), h);
+    data = (0, _mergeData.default)(data, {
+      props: props
+    });
+
+    if (props.mobile) {
+      return h(_VDataTableHeaderMobile.default, data, children);
+    } else {
+      return h(_VDataTableHeaderDesktop.default, data, children);
+    }
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=VDataTableHeader.js.map

node_modules/vuetify/es5/components/VDataTable/VDataTableHeader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VDataTable/VDataTableHeader.ts"],"names":[],"mappings":";;;;;;;AACA;;AAGA;;AACA;;AAGA;;AAGA;;AACA;;AACA;;AAGA;;;;;;;;;;AAEA;eACe,aAAI,MAAJ,CAAW;AACxB,EAAA,IAAI,EAAE,qBADkB;AAGxB,EAAA,UAAU,EAAE,IAHY;AAKxB,EAAA,KAAK,oBACA,gBAAO,OAAP,CAAe,KADf;AAEH,IAAA,MAAM,EAAE;AAFL,IALmB;AAUxB,EAAA,MAVwB,kBAUhB,CAVgB,QAUS;AAAA,QAApB,KAAoB,QAApB,KAAoB;AAAA,QAAb,IAAa,QAAb,IAAa;AAAA,QAAP,KAAO,QAAP,KAAO;AAC/B,uCAAqB,IAArB;AACA,QAAM,QAAQ,GAAG,qCAAa,KAAK,EAAlB,EAAsB,CAAtB,CAAjB;AAEA,IAAA,IAAI,GAAG,wBAAU,IAAV,EAAgB;AAAE,MAAA,KAAK,EAAL;AAAF,KAAhB,CAAP;;AAEA,QAAI,KAAK,CAAC,MAAV,EAAkB;AAChB,aAAO,CAAC,CAAC,+BAAD,EAAyB,IAAzB,EAA+B,QAA/B,CAAR;AACD,KAFD,MAEO;AACL,aAAO,CAAC,CAAC,gCAAD,EAA0B,IAA1B,EAAgC,QAAhC,CAAR;AACD;AACF;AArBuB,CAAX,C","sourcesContent":["// Styles\nimport './VDataTableHeader.sass'\n\n// Components\nimport VDataTableHeaderMobile from './VDataTableHeaderMobile'\nimport VDataTableHeaderDesktop from './VDataTableHeaderDesktop'\n\n// Mixins\nimport header from './mixins/header'\n\n// Utilities\nimport dedupeModelListeners from '../../util/dedupeModelListeners'\nimport mergeData from '../../util/mergeData'\nimport rebuildSlots from '../../util/rebuildFunctionalSlots'\n\n// Types\nimport Vue from 'vue'\n\n/* @vue/component */\nexport default Vue.extend({\n  name: 'v-data-table-header',\n\n  functional: true,\n\n  props: {\n    ...header.options.props,\n    mobile: Boolean,\n  },\n\n  render (h, { props, data, slots }) {\n    dedupeModelListeners(data)\n    const children = rebuildSlots(slots(), h)\n\n    data = mergeData(data, { props })\n\n    if (props.mobile) {\n      return h(VDataTableHeaderMobile, data, children)\n    } else {\n      return h(VDataTableHeaderDesktop, data, children)\n    }\n  },\n})\n"],"sourceRoot":"","file":"VDataTableHeader.js"}

node_modules/vuetify/es5/components/VDataTable/VDataTableHeaderDesktop.js

@@ -0,0 +1,145 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _mixins = _interopRequireDefault(require("../../util/mixins"));
+
+var _header = _interopRequireDefault(require("./mixins/header"));
+
+var _helpers = require("../../util/helpers");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
+
+function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
+
+var _default = (0, _mixins.default)(_header.default).extend({
+  name: 'v-data-table-header-desktop',
+  methods: {
+    genGroupByToggle: function genGroupByToggle(header) {
+      var _this = this;
+
+      return this.$createElement('span', {
+        on: {
+          click: function click(e) {
+            e.stopPropagation();
+
+            _this.$emit('group', header.value);
+          }
+        }
+      }, ['group']);
+    },
+    getAria: function getAria(beingSorted, isDesc) {
+      var _this2 = this;
+
+      var $t = function $t(key) {
+        return _this2.$vuetify.lang.t("$vuetify.dataTable.ariaLabel.".concat(key));
+      };
+
+      var ariaSort = 'none';
+      var ariaLabel = [$t('sortNone'), $t('activateAscending')];
+
+      if (!beingSorted) {
+        return {
+          ariaSort: ariaSort,
+          ariaLabel: ariaLabel.join(' ')
+        };
+      }
+
+      if (isDesc) {
+        ariaSort = 'descending';
+        ariaLabel = [$t('sortDescending'), $t(this.options.mustSort ? 'activateAscending' : 'activateNone')];
+      } else {
+        ariaSort = 'ascending';
+        ariaLabel = [$t('sortAscending'), $t('activateDescending')];
+      }
+
+      return {
+        ariaSort: ariaSort,
+        ariaLabel: ariaLabel.join(' ')
+      };
+    },
+    genHeader: function genHeader(header) {
+      var _this3 = this;
+
+      var data = {
+        attrs: {
+          role: 'columnheader',
+          scope: 'col',
+          'aria-label': header.text || ''
+        },
+        style: {
+          width: (0, _helpers.convertToUnit)(header.width),
+          minWidth: (0, _helpers.convertToUnit)(header.width)
+        },
+        class: ["text-".concat(header.align || 'start')].concat(_toConsumableArray((0, _helpers.wrapInArray)(header.class)), [header.divider && 'v-data-table__divider']),
+        on: {}
+      };
+      var children = [];
+
+      if (header.value === 'data-table-select' && !this.singleSelect) {
+        return this.$createElement('th', data, [this.genSelectAll()]);
+      }
+
+      children.push(this.$scopedSlots[header.value] ? this.$scopedSlots[header.value]({
+        header: header
+      }) : this.$createElement('span', [header.text]));
+
+      if (!this.disableSort && (header.sortable || !header.hasOwnProperty('sortable'))) {
+        data.on['click'] = function () {
+          return _this3.$emit('sort', header.value);
+        };
+
+        var sortIndex = this.options.sortBy.findIndex(function (k) {
+          return k === header.value;
+        });
+        var beingSorted = sortIndex >= 0;
+        var isDesc = this.options.sortDesc[sortIndex];
+        data.class.push('sortable');
+
+        var _this$getAria = this.getAria(beingSorted, isDesc),
+            ariaLabel = _this$getAria.ariaLabel,
+            ariaSort = _this$getAria.ariaSort;
+
+        data.attrs['aria-label'] += "".concat(header.text ? ': ' : '').concat(ariaLabel);
+        data.attrs['aria-sort'] = ariaSort;
+
+        if (beingSorted) {
+          data.class.push('active');
+          data.class.push(isDesc ? 'desc' : 'asc');
+        }
+
+        if (header.align === 'end') children.unshift(this.genSortIcon());else children.push(this.genSortIcon());
+
+        if (this.options.multiSort && beingSorted) {
+          children.push(this.$createElement('span', {
+            class: 'v-data-table-header__sort-badge'
+          }, [String(sortIndex + 1)]));
+        }
+      }
+
+      if (this.showGroupBy && header.groupable !== false) children.push(this.genGroupByToggle(header));
+      return this.$createElement('th', data, children);
+    }
+  },
+  render: function render() {
+    var _this4 = this;
+
+    return this.$createElement('thead', {
+      staticClass: 'v-data-table-header'
+    }, [this.$createElement('tr', this.headers.map(function (header) {
+      return _this4.genHeader(header);
+    }))]);
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=VDataTableHeaderDesktop.js.map

node_modules/vuetify/es5/components/VDataTable/VDataTableHeaderMobile.js

@@ -0,0 +1,132 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _mixins = _interopRequireDefault(require("../../util/mixins"));
+
+var _VSelect = _interopRequireDefault(require("../VSelect/VSelect"));
+
+var _VChip = _interopRequireDefault(require("../VChip"));
+
+var _header = _interopRequireDefault(require("./mixins/header"));
+
+var _helpers = require("../../util/helpers");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
+
+function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
+
+var _default = (0, _mixins.default)(_header.default).extend({
+  name: 'v-data-table-header-mobile',
+  props: {
+    sortByText: {
+      type: String,
+      default: '$vuetify.dataTable.sortBy'
+    }
+  },
+  methods: {
+    genSortChip: function genSortChip(props) {
+      var _this = this;
+
+      var children = [props.item.text];
+      var sortIndex = this.options.sortBy.findIndex(function (k) {
+        return k === props.item.value;
+      });
+      var beingSorted = sortIndex >= 0;
+      var isDesc = this.options.sortDesc[sortIndex];
+      children.push(this.$createElement('div', {
+        staticClass: 'v-chip__close',
+        class: {
+          sortable: true,
+          active: beingSorted,
+          asc: beingSorted && !isDesc,
+          desc: beingSorted && isDesc
+        }
+      }, [this.genSortIcon()]));
+      return this.$createElement(_VChip.default, {
+        staticClass: 'sortable',
+        on: {
+          click: function click(e) {
+            e.stopPropagation();
+
+            _this.$emit('sort', props.item.value);
+          }
+        }
+      }, children);
+    },
+    genSortSelect: function genSortSelect(items) {
+      var _this2 = this;
+
+      return this.$createElement(_VSelect.default, {
+        props: {
+          label: this.$vuetify.lang.t(this.sortByText),
+          items: items,
+          hideDetails: true,
+          multiple: this.options.multiSort,
+          value: this.options.multiSort ? this.options.sortBy : this.options.sortBy[0],
+          menuProps: {
+            closeOnContentClick: true
+          }
+        },
+        on: {
+          change: function change(v) {
+            return _this2.$emit('sort', v);
+          }
+        },
+        scopedSlots: {
+          selection: function selection(props) {
+            return _this2.genSortChip(props);
+          }
+        }
+      });
+    }
+  },
+  render: function render(h) {
+    var children = [];
+    var header = this.headers.find(function (h) {
+      return h.value === 'data-table-select';
+    });
+
+    if (header && !this.singleSelect) {
+      children.push(this.$createElement('div', {
+        class: ['v-data-table-header-mobile__select'].concat(_toConsumableArray((0, _helpers.wrapInArray)(header.class))),
+        attrs: {
+          width: header.width
+        }
+      }, [this.genSelectAll()]));
+    }
+
+    var sortHeaders = this.headers.filter(function (h) {
+      return h.sortable !== false && h.value !== 'data-table-select';
+    }).map(function (h) {
+      return {
+        text: h.text,
+        value: h.value
+      };
+    });
+
+    if (!this.disableSort && sortHeaders.length) {
+      children.push(this.genSortSelect(sortHeaders));
+    }
+
+    var th = h('th', [h('div', {
+      staticClass: 'v-data-table-header-mobile__wrapper'
+    }, children)]);
+    var tr = h('tr', [th]);
+    return h('thead', {
+      staticClass: 'v-data-table-header v-data-table-header-mobile'
+    }, [tr]);
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=VDataTableHeaderMobile.js.map

node_modules/vuetify/es5/components/VDataTable/VEditDialog.js

@@ -0,0 +1,155 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("../../../src/components/VDataTable/VEditDialog.sass");
+
+var _returnable = _interopRequireDefault(require("../../mixins/returnable"));
+
+var _themeable = _interopRequireDefault(require("../../mixins/themeable"));
+
+var _helpers = require("../../util/helpers");
+
+var _VBtn = _interopRequireDefault(require("../VBtn"));
+
+var _VMenu = _interopRequireDefault(require("../VMenu"));
+
+var _mixins = _interopRequireDefault(require("../../util/mixins"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Styles
+// Mixins
+// Utils
+// Component
+
+/* @vue/component */
+var _default = (0, _mixins.default)(_returnable.default, _themeable.default).extend({
+  name: 'v-edit-dialog',
+  props: {
+    cancelText: {
+      default: 'Cancel'
+    },
+    large: Boolean,
+    eager: Boolean,
+    persistent: Boolean,
+    saveText: {
+      default: 'Save'
+    },
+    transition: {
+      type: String,
+      default: 'slide-x-reverse-transition'
+    }
+  },
+  data: function data() {
+    return {
+      isActive: false
+    };
+  },
+  watch: {
+    isActive: function isActive(val) {
+      if (val) {
+        this.$emit('open');
+        setTimeout(this.focus, 50); // Give DOM time to paint
+      } else {
+        this.$emit('close');
+      }
+    }
+  },
+  methods: {
+    cancel: function cancel() {
+      this.isActive = false;
+      this.$emit('cancel');
+    },
+    focus: function focus() {
+      var input = this.$refs.content.querySelector('input');
+      input && input.focus();
+    },
+    genButton: function genButton(fn, text) {
+      return this.$createElement(_VBtn.default, {
+        props: {
+          text: true,
+          color: 'primary',
+          light: true
+        },
+        on: {
+          click: fn
+        }
+      }, text);
+    },
+    genActions: function genActions() {
+      var _this = this;
+
+      return this.$createElement('div', {
+        class: 'v-small-dialog__actions'
+      }, [this.genButton(this.cancel, this.cancelText), this.genButton(function () {
+        _this.save(_this.returnValue);
+
+        _this.$emit('save');
+      }, this.saveText)]);
+    },
+    genContent: function genContent() {
+      var _this2 = this;
+
+      return this.$createElement('div', {
+        staticClass: 'v-small-dialog__content',
+        on: {
+          keydown: function keydown(e) {
+            var input = _this2.$refs.content.querySelector('input');
+
+            e.keyCode === _helpers.keyCodes.esc && _this2.cancel();
+
+            if (e.keyCode === _helpers.keyCodes.enter && input) {
+              _this2.save(input.value);
+
+              _this2.$emit('save');
+            }
+          }
+        },
+        ref: 'content'
+      }, [this.$slots.input]);
+    }
+  },
+  render: function render(h) {
+    var _this3 = this;
+
+    return h(_VMenu.default, {
+      staticClass: 'v-small-dialog',
+      class: this.themeClasses,
+      props: {
+        contentClass: 'v-small-dialog__menu-content',
+        transition: this.transition,
+        origin: 'top right',
+        right: true,
+        value: this.isActive,
+        closeOnClick: !this.persistent,
+        closeOnContentClick: false,
+        eager: this.eager,
+        light: this.light,
+        dark: this.dark
+      },
+      on: {
+        input: function input(val) {
+          return _this3.isActive = val;
+        }
+      },
+      scopedSlots: {
+        activator: function activator(_ref) {
+          var on = _ref.on;
+          return h('div', {
+            staticClass: 'v-small-dialog__activator',
+            on: on
+          }, [h('span', {
+            staticClass: 'v-small-dialog__activator__content'
+          }, _this3.$slots.default)]);
+        }
+      }
+    }, [this.genContent(), this.large ? this.genActions() : null]);
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=VEditDialog.js.map

node_modules/vuetify/es5/components/VDataTable/VSimpleTable.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("../../../src/components/VDataTable/VSimpleTable.sass");
+
+var _helpers = require("../../util/helpers");
+
+var _themeable = _interopRequireDefault(require("../../mixins/themeable"));
+
+var _mixins = _interopRequireDefault(require("../../util/mixins"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var _default = (0, _mixins.default)(_themeable.default).extend({
+  name: 'v-simple-table',
+  props: {
+    dense: Boolean,
+    fixedHeader: Boolean,
+    height: [Number, String]
+  },
+  computed: {
+    classes: function classes() {
+      return _objectSpread({
+        'v-data-table--dense': this.dense,
+        'v-data-table--fixed-height': !!this.height && !this.fixedHeader,
+        'v-data-table--fixed-header': this.fixedHeader
+      }, this.themeClasses);
+    }
+  },
+  methods: {
+    genWrapper: function genWrapper() {
+      return this.$slots.wrapper || this.$createElement('div', {
+        staticClass: 'v-data-table__wrapper',
+        style: {
+          height: (0, _helpers.convertToUnit)(this.height)
+        }
+      }, [this.$createElement('table', this.$slots.default)]);
+    }
+  },
+  render: function render(h) {
+    return h('div', {
+      staticClass: 'v-data-table',
+      class: this.classes
+    }, [this.$slots.top, this.genWrapper(), this.$slots.bottom]);
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=VSimpleTable.js.map

node_modules/vuetify/es5/components/VDataTable/VSimpleTable.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VDataTable/VSimpleTable.ts"],"names":[],"mappings":";;;;;;;AAAA;;AAEA;;AACA;;AACA;;;;;;;;;;eAGe,qBAAO,kBAAP,EAAkB,MAAlB,CAAyB;AACtC,EAAA,IAAI,EAAE,gBADgC;AAGtC,EAAA,KAAK,EAAE;AACL,IAAA,KAAK,EAAE,OADF;AAEL,IAAA,WAAW,EAAE,OAFR;AAGL,IAAA,MAAM,EAAE,CAAC,MAAD,EAAS,MAAT;AAHH,GAH+B;AAStC,EAAA,QAAQ,EAAE;AACR,IAAA,OADQ,qBACD;AACL;AACE,+BAAuB,KAAK,KAD9B;AAEE,sCAA8B,CAAC,CAAC,KAAK,MAAP,IAAiB,CAAC,KAAK,WAFvD;AAGE,sCAA8B,KAAK;AAHrC,SAIK,KAAK,YAJV;AAMD;AARO,GAT4B;AAoBtC,EAAA,OAAO,EAAE;AACP,IAAA,UADO,wBACG;AACR,aAAO,KAAK,MAAL,CAAY,OAAZ,IAAuB,KAAK,cAAL,CAAoB,KAApB,EAA2B;AACvD,QAAA,WAAW,EAAE,uBAD0C;AAEvD,QAAA,KAAK,EAAE;AACL,UAAA,MAAM,EAAE,4BAAc,KAAK,MAAnB;AADH;AAFgD,OAA3B,EAK3B,CACD,KAAK,cAAL,CAAoB,OAApB,EAA6B,KAAK,MAAL,CAAY,OAAzC,CADC,CAL2B,CAA9B;AAQD;AAVM,GApB6B;AAiCtC,EAAA,MAjCsC,kBAiC9B,CAjC8B,EAiC7B;AACP,WAAO,CAAC,CAAC,KAAD,EAAQ;AACd,MAAA,WAAW,EAAE,cADC;AAEd,MAAA,KAAK,EAAE,KAAK;AAFE,KAAR,EAGL,CACD,KAAK,MAAL,CAAY,GADX,EAED,KAAK,UAAL,EAFC,EAGD,KAAK,MAAL,CAAY,MAHX,CAHK,CAAR;AAQD;AA1CqC,CAAzB,C","sourcesContent":["import './VSimpleTable.sass'\n\nimport { convertToUnit } from '../../util/helpers'\nimport Themeable from '../../mixins/themeable'\nimport mixins from '../../util/mixins'\nimport { VNode } from 'vue'\n\nexport default mixins(Themeable).extend({\n  name: 'v-simple-table',\n\n  props: {\n    dense: Boolean,\n    fixedHeader: Boolean,\n    height: [Number, String],\n  },\n\n  computed: {\n    classes (): Record<string, boolean> {\n      return {\n        'v-data-table--dense': this.dense,\n        'v-data-table--fixed-height': !!this.height && !this.fixedHeader,\n        'v-data-table--fixed-header': this.fixedHeader,\n        ...this.themeClasses,\n      }\n    },\n  },\n\n  methods: {\n    genWrapper () {\n      return this.$slots.wrapper || this.$createElement('div', {\n        staticClass: 'v-data-table__wrapper',\n        style: {\n          height: convertToUnit(this.height),\n        },\n      }, [\n        this.$createElement('table', this.$slots.default),\n      ])\n    },\n  },\n\n  render (h): VNode {\n    return h('div', {\n      staticClass: 'v-data-table',\n      class: this.classes,\n    }, [\n      this.$slots.top,\n      this.genWrapper(),\n      this.$slots.bottom,\n    ])\n  },\n})\n"],"sourceRoot":"","file":"VSimpleTable.js"}

node_modules/vuetify/es5/components/VDataTable/VVirtualTable.js

@@ -0,0 +1,151 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("../../../src/components/VDataTable/VVirtualTable.sass");
+
+var _VSimpleTable = _interopRequireDefault(require("./VSimpleTable"));
+
+var _mixins = _interopRequireDefault(require("../../util/mixins"));
+
+var _helpers = require("../../util/helpers");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Components
+// Utiltiies
+// Types
+var baseMixins = (0, _mixins.default)(_VSimpleTable.default);
+
+var _default2 = baseMixins.extend().extend({
+  name: 'v-virtual-table',
+  props: {
+    chunkSize: {
+      type: Number,
+      default: 25
+    },
+    headerHeight: {
+      type: Number,
+      default: 48
+    },
+    items: {
+      type: Array,
+      default: function _default() {
+        return [];
+      }
+    },
+    rowHeight: {
+      type: Number,
+      default: 48
+    }
+  },
+  data: function data() {
+    return {
+      scrollTop: 0,
+      oldChunk: 0,
+      scrollDebounce: null,
+      invalidateCache: false
+    };
+  },
+  computed: {
+    itemsLength: function itemsLength() {
+      return this.items.length;
+    },
+    totalHeight: function totalHeight() {
+      return this.itemsLength * this.rowHeight + this.headerHeight;
+    },
+    topIndex: function topIndex() {
+      return Math.floor(this.scrollTop / this.rowHeight);
+    },
+    chunkIndex: function chunkIndex() {
+      return Math.floor(this.topIndex / this.chunkSize);
+    },
+    startIndex: function startIndex() {
+      return Math.max(0, this.chunkIndex * this.chunkSize - this.chunkSize);
+    },
+    offsetTop: function offsetTop() {
+      return Math.max(0, this.startIndex * this.rowHeight);
+    },
+    stopIndex: function stopIndex() {
+      return Math.min(this.startIndex + this.chunkSize * 3, this.itemsLength);
+    },
+    offsetBottom: function offsetBottom() {
+      return Math.max(0, (this.itemsLength - this.stopIndex - this.startIndex) * this.rowHeight);
+    }
+  },
+  watch: {
+    chunkIndex: function chunkIndex(newValue, oldValue) {
+      this.oldChunk = oldValue;
+    },
+    items: function items() {
+      this.cachedItems = null;
+      this.$refs.table.scrollTop = 0;
+    }
+  },
+  created: function created() {
+    this.cachedItems = null;
+  },
+  mounted: function mounted() {
+    this.scrollDebounce = (0, _helpers.debounce)(this.onScroll, 50);
+    this.$refs.table.addEventListener('scroll', this.scrollDebounce, {
+      passive: true
+    });
+  },
+  beforeDestroy: function beforeDestroy() {
+    this.$refs.table.removeEventListener('scroll', this.scrollDebounce);
+  },
+  methods: {
+    createStyleHeight: function createStyleHeight(height) {
+      return {
+        height: "".concat(height, "px")
+      };
+    },
+    genBody: function genBody() {
+      if (this.cachedItems === null || this.chunkIndex !== this.oldChunk) {
+        this.cachedItems = this.genItems();
+        this.oldChunk = this.chunkIndex;
+      }
+
+      return this.$createElement('tbody', [this.$createElement('tr', {
+        style: this.createStyleHeight(this.offsetTop)
+      }), this.cachedItems, this.$createElement('tr', {
+        style: this.createStyleHeight(this.offsetBottom)
+      })]);
+    },
+    genItems: function genItems() {
+      return this.$scopedSlots.items({
+        items: this.items.slice(this.startIndex, this.stopIndex)
+      });
+    },
+    onScroll: function onScroll(e) {
+      var target = e.target;
+      this.scrollTop = target.scrollTop;
+    },
+    genTable: function genTable() {
+      return this.$createElement('div', {
+        ref: 'table',
+        staticClass: 'v-virtual-table__table'
+      }, [this.$createElement('table', [this.$slots['body.before'], this.genBody(), this.$slots['body.after']])]);
+    },
+    genWrapper: function genWrapper() {
+      return this.$createElement('div', {
+        staticClass: 'v-virtual-table__wrapper',
+        style: {
+          height: (0, _helpers.convertToUnit)(this.height)
+        }
+      }, [this.genTable()]);
+    }
+  },
+  render: function render(h) {
+    return h('div', {
+      staticClass: 'v-data-table v-virtual-table',
+      class: this.classes
+    }, [this.$slots.top, this.genWrapper(), this.$slots.bottom]);
+  }
+});
+
+exports.default = _default2;
+//# sourceMappingURL=VVirtualTable.js.map

node_modules/vuetify/es5/components/VDataTable/index.js

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "VDataTable", {
+  enumerable: true,
+  get: function get() {
+    return _VDataTable.default;
+  }
+});
+Object.defineProperty(exports, "VDataTableHeader", {
+  enumerable: true,
+  get: function get() {
+    return _VDataTableHeader.default;
+  }
+});
+Object.defineProperty(exports, "VEditDialog", {
+  enumerable: true,
+  get: function get() {
+    return _VEditDialog.default;
+  }
+});
+Object.defineProperty(exports, "VSimpleTable", {
+  enumerable: true,
+  get: function get() {
+    return _VSimpleTable.default;
+  }
+});
+Object.defineProperty(exports, "VVirtualTable", {
+  enumerable: true,
+  get: function get() {
+    return _VVirtualTable.default;
+  }
+});
+exports.default = exports.VTableOverflow = void 0;
+
+var _helpers = require("../../util/helpers");
+
+var _VDataTable = _interopRequireDefault(require("./VDataTable"));
+
+var _VDataTableHeader = _interopRequireDefault(require("./VDataTableHeader"));
+
+var _VEditDialog = _interopRequireDefault(require("./VEditDialog"));
+
+var _VSimpleTable = _interopRequireDefault(require("./VSimpleTable"));
+
+var _VVirtualTable = _interopRequireDefault(require("./VVirtualTable"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var VTableOverflow = (0, _helpers.createSimpleFunctional)('v-table__overflow');
+exports.VTableOverflow = VTableOverflow;
+var _default = {
+  $_vuetify_subcomponents: {
+    VDataTable: _VDataTable.default,
+    VDataTableHeader: _VDataTableHeader.default,
+    VEditDialog: _VEditDialog.default,
+    VTableOverflow: VTableOverflow,
+    VSimpleTable: _VSimpleTable.default,
+    VVirtualTable: _VVirtualTable.default
+  }
+};
+exports.default = _default;
+//# sourceMappingURL=index.js.map

node_modules/vuetify/es5/components/VDataTable/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/VDataTable/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;AAEA;;AACA;;AACA;;AACA;;AACA;;;;AAEA,IAAM,cAAc,GAAG,qCAAuB,mBAAvB,CAAvB;;eAIe;AACb,EAAA,uBAAuB,EAAE;AACvB,IAAA,UAAU,EAAV,mBADuB;AAEvB,IAAA,gBAAgB,EAAhB,yBAFuB;AAGvB,IAAA,WAAW,EAAX,oBAHuB;AAIvB,IAAA,cAAc,EAAd,cAJuB;AAKvB,IAAA,YAAY,EAAZ,qBALuB;AAMvB,IAAA,aAAa,EAAb;AANuB;AADZ,C","sourcesContent":["import { createSimpleFunctional } from '../../util/helpers'\n\nimport VDataTable from './VDataTable'\nimport VDataTableHeader from './VDataTableHeader'\nimport VEditDialog from './VEditDialog'\nimport VSimpleTable from './VSimpleTable'\nimport VVirtualTable from './VVirtualTable'\n\nconst VTableOverflow = createSimpleFunctional('v-table__overflow')\n\nexport { VDataTable, VEditDialog, VTableOverflow, VDataTableHeader, VSimpleTable, VVirtualTable }\n\nexport default {\n  $_vuetify_subcomponents: {\n    VDataTable,\n    VDataTableHeader,\n    VEditDialog,\n    VTableOverflow,\n    VSimpleTable,\n    VVirtualTable,\n  },\n}\n"],"sourceRoot":"","file":"index.js"}

node_modules/vuetify/es5/components/VDataTable/mixins/header.js

@@ -0,0 +1,97 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _VIcon = _interopRequireDefault(require("../../VIcon"));
+
+var _VSimpleCheckbox = _interopRequireDefault(require("../../VCheckbox/VSimpleCheckbox"));
+
+var _ripple = _interopRequireDefault(require("../../../directives/ripple"));
+
+var _mixins = _interopRequireDefault(require("../../../util/mixins"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var _default2 = (0, _mixins.default)().extend({
+  // https://github.com/vuejs/vue/issues/6872
+  directives: {
+    ripple: _ripple.default
+  },
+  props: {
+    headers: {
+      type: Array,
+      default: function _default() {
+        return [];
+      }
+    },
+    options: {
+      type: Object,
+      default: function _default() {
+        return {
+          page: 1,
+          itemsPerPage: 10,
+          sortBy: [],
+          sortDesc: [],
+          groupBy: [],
+          groupDesc: [],
+          multiSort: false,
+          mustSort: false
+        };
+      }
+    },
+    sortIcon: {
+      type: String,
+      default: '$sort'
+    },
+    everyItem: Boolean,
+    someItems: Boolean,
+    showGroupBy: Boolean,
+    singleSelect: Boolean,
+    disableSort: Boolean
+  },
+  methods: {
+    genSelectAll: function genSelectAll() {
+      var _this = this;
+
+      var data = {
+        props: {
+          value: this.everyItem,
+          indeterminate: !this.everyItem && this.someItems
+        },
+        on: {
+          input: function input(v) {
+            return _this.$emit('toggle-select-all', v);
+          }
+        }
+      };
+
+      if (this.$scopedSlots['data-table-select']) {
+        return this.$scopedSlots['data-table-select'](data);
+      }
+
+      return this.$createElement(_VSimpleCheckbox.default, _objectSpread({
+        staticClass: 'v-data-table__checkbox'
+      }, data));
+    },
+    genSortIcon: function genSortIcon() {
+      return this.$createElement(_VIcon.default, {
+        staticClass: 'v-data-table-header__icon',
+        props: {
+          size: 18
+        }
+      }, [this.sortIcon]);
+    }
+  }
+});
+
+exports.default = _default2;
+//# sourceMappingURL=header.js.map

node_modules/vuetify/es5/components/VDataTable/mixins/header.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/components/VDataTable/mixins/header.ts"],"names":[],"mappings":";;;;;;;AACA;;AACA;;AACA;;AAGA;;;;;;;;;;gBASe,uBAAkB,MAAlB,CAAyB;AACtC;AACA,EAAA,UAAU,EAAE;AACV,IAAA,MAAM,EAAN;AADU,GAF0B;AAMtC,EAAA,KAAK,EAAE;AACL,IAAA,OAAO,EAAE;AACP,MAAA,IAAI,EAAE,KADC;AAEP,MAAA,OAAO,EAAE;AAAA,eAAO,EAAP;AAAA;AAFF,KADJ;AAKL,IAAA,OAAO,EAAE;AACP,MAAA,IAAI,EAAE,MADC;AAEP,MAAA,OAAO,EAAE;AAAA,eAAO;AACd,UAAA,IAAI,EAAE,CADQ;AAEd,UAAA,YAAY,EAAE,EAFA;AAGd,UAAA,MAAM,EAAE,EAHM;AAId,UAAA,QAAQ,EAAE,EAJI;AAKd,UAAA,OAAO,EAAE,EALK;AAMd,UAAA,SAAS,EAAE,EANG;AAOd,UAAA,SAAS,EAAE,KAPG;AAQd,UAAA,QAAQ,EAAE;AARI,SAAP;AAAA;AAFF,KALJ;AAkBL,IAAA,QAAQ,EAAE;AACR,MAAA,IAAI,EAAE,MADE;AAER,MAAA,OAAO,EAAE;AAFD,KAlBL;AAsBL,IAAA,SAAS,EAAE,OAtBN;AAuBL,IAAA,SAAS,EAAE,OAvBN;AAwBL,IAAA,WAAW,EAAE,OAxBR;AAyBL,IAAA,YAAY,EAAE,OAzBT;AA0BL,IAAA,WAAW,EAAE;AA1BR,GAN+B;AAmCtC,EAAA,OAAO,EAAE;AACP,IAAA,YADO,0BACK;AAAA;;AACV,UAAM,IAAI,GAAG;AACX,QAAA,KAAK,EAAE;AACL,UAAA,KAAK,EAAE,KAAK,SADP;AAEL,UAAA,aAAa,EAAE,CAAC,KAAK,SAAN,IAAmB,KAAK;AAFlC,SADI;AAKX,QAAA,EAAE,EAAE;AACF,UAAA,KAAK,EAAE,eAAC,CAAD;AAAA,mBAAgB,KAAI,CAAC,KAAL,CAAW,mBAAX,EAAgC,CAAhC,CAAhB;AAAA;AADL;AALO,OAAb;;AAUA,UAAI,KAAK,YAAL,CAAkB,mBAAlB,CAAJ,EAA4C;AAC1C,eAAO,KAAK,YAAL,CAAkB,mBAAlB,EAAwC,IAAxC,CAAP;AACD;;AAED,aAAO,KAAK,cAAL,CAAoB,wBAApB;AACL,QAAA,WAAW,EAAE;AADR,SAEF,IAFE,EAAP;AAID,KApBM;AAqBP,IAAA,WArBO,yBAqBI;AACT,aAAO,KAAK,cAAL,CAAoB,cAApB,EAA2B;AAChC,QAAA,WAAW,EAAE,2BADmB;AAEhC,QAAA,KAAK,EAAE;AACL,UAAA,IAAI,EAAE;AADD;AAFyB,OAA3B,EAKJ,CAAC,KAAK,QAAN,CALI,CAAP;AAMD;AA5BM;AAnC6B,CAAzB,C","sourcesContent":["import { VDataTable } from '../'\nimport VIcon from '../../VIcon'\nimport VSimpleCheckbox from '../../VCheckbox/VSimpleCheckbox'\nimport ripple from '../../../directives/ripple'\n\nimport Vue, { PropType } from 'vue'\nimport mixins from '../../../util/mixins'\nimport { DataOptions, DataTableHeader } from 'vuetify/types'\n\ntype VDataTableInstance = InstanceType<typeof VDataTable>\n\ninterface options extends Vue {\n  dataTable: VDataTableInstance\n}\n\nexport default mixins<options>().extend({\n  // https://github.com/vuejs/vue/issues/6872\n  directives: {\n    ripple,\n  },\n\n  props: {\n    headers: {\n      type: Array as PropType<DataTableHeader[]>,\n      default: () => ([]),\n    },\n    options: {\n      type: Object as PropType<DataOptions>,\n      default: () => ({\n        page: 1,\n        itemsPerPage: 10,\n        sortBy: [],\n        sortDesc: [],\n        groupBy: [],\n        groupDesc: [],\n        multiSort: false,\n        mustSort: false,\n      }),\n    },\n    sortIcon: {\n      type: String,\n      default: '$sort',\n    },\n    everyItem: Boolean,\n    someItems: Boolean,\n    showGroupBy: Boolean,\n    singleSelect: Boolean,\n    disableSort: Boolean,\n  },\n\n  methods: {\n    genSelectAll () {\n      const data = {\n        props: {\n          value: this.everyItem,\n          indeterminate: !this.everyItem && this.someItems,\n        },\n        on: {\n          input: (v: boolean) => this.$emit('toggle-select-all', v),\n        },\n      }\n\n      if (this.$scopedSlots['data-table-select']) {\n        return this.$scopedSlots['data-table-select']!(data)\n      }\n\n      return this.$createElement(VSimpleCheckbox, {\n        staticClass: 'v-data-table__checkbox',\n        ...data,\n      })\n    },\n    genSortIcon () {\n      return this.$createElement(VIcon, {\n        staticClass: 'v-data-table-header__icon',\n        props: {\n          size: 18,\n        },\n      }, [this.sortIcon])\n    },\n  },\n})\n"],"sourceRoot":"","file":"header.js"}