first commit, after modifying client section

public/assets/vendors/tabulator/js/modules/accessor.js

@@ -0,0 +1,93 @@
+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; };
+
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+
+var Accessor = function Accessor(table) {
+	this.table = table; //hold Tabulator object
+	this.allowedTypes = ["", "data", "download", "clipboard", "print", "htmlOutput"]; //list of accessor types
+};
+
+//initialize column accessor
+Accessor.prototype.initializeColumn = function (column) {
+	var self = this,
+	    match = false,
+	    config = {};
+
+	this.allowedTypes.forEach(function (type) {
+		var key = "accessor" + (type.charAt(0).toUpperCase() + type.slice(1)),
+		    accessor;
+
+		if (column.definition[key]) {
+			accessor = self.lookupAccessor(column.definition[key]);
+
+			if (accessor) {
+				match = true;
+
+				config[key] = {
+					accessor: accessor,
+					params: column.definition[key + "Params"] || {}
+				};
+			}
+		}
+	});
+
+	if (match) {
+		column.modules.accessor = config;
+	}
+};
+
+Accessor.prototype.lookupAccessor = function (value) {
+	var accessor = false;
+
+	//set column accessor
+	switch (typeof value === "undefined" ? "undefined" : _typeof(value)) {
+		case "string":
+			if (this.accessors[value]) {
+				accessor = this.accessors[value];
+			} else {
+				console.warn("Accessor Error - No such accessor found, ignoring: ", value);
+			}
+			break;
+
+		case "function":
+			accessor = value;
+			break;
+	}
+
+	return accessor;
+};
+
+//apply accessor to row
+Accessor.prototype.transformRow = function (row, type) {
+	var key = "accessor" + (type.charAt(0).toUpperCase() + type.slice(1)),
+	    rowComponent = row.getComponent();
+
+	//clone data object with deep copy to isolate internal data from returned result
+	var data = Tabulator.prototype.helpers.deepClone(row.data || {});
+
+	this.table.columnManager.traverse(function (column) {
+		var value, accessor, params, colCompnent;
+
+		if (column.modules.accessor) {
+
+			accessor = column.modules.accessor[key] || column.modules.accessor.accessor || false;
+
+			if (accessor) {
+				value = column.getFieldValue(data);
+
+				if (value != "undefined") {
+					colCompnent = column.getComponent();
+					params = typeof accessor.params === "function" ? accessor.params(value, data, type, colCompnent, rowComponent) : accessor.params;
+					column.setFieldValue(data, accessor.accessor(value, data, type, params, colCompnent, rowComponent));
+				}
+			}
+		}
+	});
+
+	return data;
+},
+
+//default accessors
+Accessor.prototype.accessors = {};
+
+Tabulator.prototype.registerModule("accessor", Accessor);

public/assets/vendors/tabulator/js/modules/accessor.min.js

@@ -0,0 +1,2 @@
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+var _typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(o){return typeof o}:function(o){return o&&"function"==typeof Symbol&&o.constructor===Symbol&&o!==Symbol.prototype?"symbol":typeof o},Accessor=function(o){this.table=o,this.allowedTypes=["","data","download","clipboard","print","htmlOutput"]};Accessor.prototype.initializeColumn=function(o){var e=this,s=!1,t={};this.allowedTypes.forEach(function(r){var c,a="accessor"+(r.charAt(0).toUpperCase()+r.slice(1));o.definition[a]&&(c=e.lookupAccessor(o.definition[a]))&&(s=!0,t[a]={accessor:c,params:o.definition[a+"Params"]||{}})}),s&&(o.modules.accessor=t)},Accessor.prototype.lookupAccessor=function(o){var e=!1;switch(void 0===o?"undefined":_typeof(o)){case"string":this.accessors[o]?e=this.accessors[o]:console.warn("Accessor Error - No such accessor found, ignoring: ",o);break;case"function":e=o}return e},Accessor.prototype.transformRow=function(o,e){var s="accessor"+(e.charAt(0).toUpperCase()+e.slice(1)),t=o.getComponent(),r=Tabulator.prototype.helpers.deepClone(o.data||{});return this.table.columnManager.traverse(function(o){var c,a,n,i;o.modules.accessor&&(a=o.modules.accessor[s]||o.modules.accessor.accessor||!1)&&"undefined"!=(c=o.getFieldValue(r))&&(i=o.getComponent(),n="function"==typeof a.params?a.params(c,r,e,i,t):a.params,o.setFieldValue(r,a.accessor(c,r,e,n,i,t)))}),r},Accessor.prototype.accessors={},Tabulator.prototype.registerModule("accessor",Accessor);

public/assets/vendors/tabulator/js/modules/ajax.js

@@ -0,0 +1,465 @@
+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; };
+
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+
+var Ajax = function Ajax(table) {
+
+	this.table = table; //hold Tabulator object
+	this.config = false; //hold config object for ajax request
+	this.url = ""; //request URL
+	this.urlGenerator = false;
+	this.params = false; //request parameters
+
+	this.loaderElement = this.createLoaderElement(); //loader message div
+	this.msgElement = this.createMsgElement(); //message element
+	this.loadingElement = false;
+	this.errorElement = false;
+	this.loaderPromise = false;
+
+	this.progressiveLoad = false;
+	this.loading = false;
+
+	this.requestOrder = 0; //prevent requests comming out of sequence if overridden by another load request
+};
+
+//initialize setup options
+Ajax.prototype.initialize = function () {
+	var template;
+
+	this.loaderElement.appendChild(this.msgElement);
+
+	if (this.table.options.ajaxLoaderLoading) {
+		if (typeof this.table.options.ajaxLoaderLoading == "string") {
+			template = document.createElement('template');
+			template.innerHTML = this.table.options.ajaxLoaderLoading.trim();
+			this.loadingElement = template.content.firstChild;
+		} else {
+			this.loadingElement = this.table.options.ajaxLoaderLoading;
+		}
+	}
+
+	this.loaderPromise = this.table.options.ajaxRequestFunc || this.defaultLoaderPromise;
+
+	this.urlGenerator = this.table.options.ajaxURLGenerator || this.defaultURLGenerator;
+
+	if (this.table.options.ajaxLoaderError) {
+		if (typeof this.table.options.ajaxLoaderError == "string") {
+			template = document.createElement('template');
+			template.innerHTML = this.table.options.ajaxLoaderError.trim();
+			this.errorElement = template.content.firstChild;
+		} else {
+			this.errorElement = this.table.options.ajaxLoaderError;
+		}
+	}
+
+	if (this.table.options.ajaxParams) {
+		this.setParams(this.table.options.ajaxParams);
+	}
+
+	if (this.table.options.ajaxConfig) {
+		this.setConfig(this.table.options.ajaxConfig);
+	}
+
+	if (this.table.options.ajaxURL) {
+		this.setUrl(this.table.options.ajaxURL);
+	}
+
+	if (this.table.options.ajaxProgressiveLoad) {
+		if (this.table.options.pagination) {
+			this.progressiveLoad = false;
+			console.error("Progressive Load Error - Pagination and progressive load cannot be used at the same time");
+		} else {
+			if (this.table.modExists("page")) {
+				this.progressiveLoad = this.table.options.ajaxProgressiveLoad;
+				this.table.modules.page.initializeProgressive(this.progressiveLoad);
+			} else {
+				console.error("Pagination plugin is required for progressive ajax loading");
+			}
+		}
+	}
+};
+
+Ajax.prototype.createLoaderElement = function () {
+	var el = document.createElement("div");
+	el.classList.add("tabulator-loader");
+	return el;
+};
+
+Ajax.prototype.createMsgElement = function () {
+	var el = document.createElement("div");
+
+	el.classList.add("tabulator-loader-msg");
+	el.setAttribute("role", "alert");
+
+	return el;
+};
+
+//set ajax params
+Ajax.prototype.setParams = function (params, update) {
+	if (update) {
+		this.params = this.params || {};
+
+		for (var key in params) {
+			this.params[key] = params[key];
+		}
+	} else {
+		this.params = params;
+	}
+};
+
+Ajax.prototype.getParams = function () {
+	return this.params || {};
+};
+
+//load config object
+Ajax.prototype.setConfig = function (config) {
+	this._loadDefaultConfig();
+
+	if (typeof config == "string") {
+		this.config.method = config;
+	} else {
+		for (var key in config) {
+			this.config[key] = config[key];
+		}
+	}
+};
+
+//create config object from default
+Ajax.prototype._loadDefaultConfig = function (force) {
+	var self = this;
+	if (!self.config || force) {
+
+		self.config = {};
+
+		//load base config from defaults
+		for (var key in self.defaultConfig) {
+			self.config[key] = self.defaultConfig[key];
+		}
+	}
+};
+
+//set request url
+Ajax.prototype.setUrl = function (url) {
+	this.url = url;
+};
+
+//get request url
+Ajax.prototype.getUrl = function () {
+	return this.url;
+};
+
+//lstandard loading function
+Ajax.prototype.loadData = function (inPosition, columnsChanged) {
+	var self = this;
+
+	if (this.progressiveLoad) {
+		return this._loadDataProgressive();
+	} else {
+		return this._loadDataStandard(inPosition, columnsChanged);
+	}
+};
+
+Ajax.prototype.nextPage = function (diff) {
+	var margin;
+
+	if (!this.loading) {
+
+		margin = this.table.options.ajaxProgressiveLoadScrollMargin || this.table.rowManager.getElement().clientHeight * 2;
+
+		if (diff < margin) {
+			this.table.modules.page.nextPage().then(function () {}).catch(function () {});
+		}
+	}
+};
+
+Ajax.prototype.blockActiveRequest = function () {
+	this.requestOrder++;
+};
+
+Ajax.prototype._loadDataProgressive = function () {
+	this.table.rowManager.setData([]);
+	return this.table.modules.page.setPage(1);
+};
+
+Ajax.prototype._loadDataStandard = function (inPosition, columnsChanged) {
+	var _this = this;
+
+	return new Promise(function (resolve, reject) {
+		_this.sendRequest(inPosition).then(function (data) {
+			_this.table.rowManager.setData(data, inPosition, columnsChanged).then(function () {
+				resolve();
+			}).catch(function (e) {
+				reject(e);
+			});
+		}).catch(function (e) {
+			reject(e);
+		});
+	});
+};
+
+Ajax.prototype.generateParamsList = function (data, prefix) {
+	var self = this,
+	    output = [];
+
+	prefix = prefix || "";
+
+	if (Array.isArray(data)) {
+		data.forEach(function (item, i) {
+			output = output.concat(self.generateParamsList(item, prefix ? prefix + "[" + i + "]" : i));
+		});
+	} else if ((typeof data === "undefined" ? "undefined" : _typeof(data)) === "object") {
+		for (var key in data) {
+			output = output.concat(self.generateParamsList(data[key], prefix ? prefix + "[" + key + "]" : key));
+		}
+	} else {
+		output.push({ key: prefix, value: data });
+	}
+
+	return output;
+};
+
+Ajax.prototype.serializeParams = function (params) {
+	var output = this.generateParamsList(params),
+	    encoded = [];
+
+	output.forEach(function (item) {
+		encoded.push(encodeURIComponent(item.key) + "=" + encodeURIComponent(item.value));
+	});
+
+	return encoded.join("&");
+};
+
+//send ajax request
+Ajax.prototype.sendRequest = function (silent) {
+	var _this2 = this;
+
+	var self = this,
+	    url = self.url,
+	    requestNo,
+	    esc,
+	    query;
+
+	self.requestOrder++;
+	requestNo = self.requestOrder;
+
+	self._loadDefaultConfig();
+
+	return new Promise(function (resolve, reject) {
+		if (self.table.options.ajaxRequesting.call(_this2.table, self.url, self.params) !== false) {
+
+			self.loading = true;
+
+			if (!silent) {
+				self.showLoader();
+			}
+
+			_this2.loaderPromise(url, self.config, self.params).then(function (data) {
+				if (requestNo === self.requestOrder) {
+					if (self.table.options.ajaxResponse) {
+						data = self.table.options.ajaxResponse.call(self.table, self.url, self.params, data);
+					}
+					resolve(data);
+
+					self.hideLoader();
+					self.loading = false;
+				} else {
+					console.warn("Ajax Response Blocked - An active ajax request was blocked by an attempt to change table data while the request was being made");
+				}
+			}).catch(function (error) {
+				console.error("Ajax Load Error: ", error);
+				self.table.options.ajaxError.call(self.table, error);
+
+				self.showError();
+
+				setTimeout(function () {
+					self.hideLoader();
+				}, 3000);
+
+				self.loading = false;
+
+				reject(error);
+			});
+		} else {
+			reject();
+		}
+	});
+};
+
+Ajax.prototype.showLoader = function () {
+	var shouldLoad = typeof this.table.options.ajaxLoader === "function" ? this.table.options.ajaxLoader() : this.table.options.ajaxLoader;
+
+	if (shouldLoad) {
+
+		this.hideLoader();
+
+		while (this.msgElement.firstChild) {
+			this.msgElement.removeChild(this.msgElement.firstChild);
+		}this.msgElement.classList.remove("tabulator-error");
+		this.msgElement.classList.add("tabulator-loading");
+
+		if (this.loadingElement) {
+			this.msgElement.appendChild(this.loadingElement);
+		} else {
+			this.msgElement.innerHTML = this.table.modules.localize.getText("ajax|loading");
+		}
+
+		this.table.element.appendChild(this.loaderElement);
+	}
+};
+
+Ajax.prototype.showError = function () {
+	this.hideLoader();
+
+	while (this.msgElement.firstChild) {
+		this.msgElement.removeChild(this.msgElement.firstChild);
+	}this.msgElement.classList.remove("tabulator-loading");
+	this.msgElement.classList.add("tabulator-error");
+
+	if (this.errorElement) {
+		this.msgElement.appendChild(this.errorElement);
+	} else {
+		this.msgElement.innerHTML = this.table.modules.localize.getText("ajax|error");
+	}
+
+	this.table.element.appendChild(this.loaderElement);
+};
+
+Ajax.prototype.hideLoader = function () {
+	if (this.loaderElement.parentNode) {
+		this.loaderElement.parentNode.removeChild(this.loaderElement);
+	}
+};
+
+//default ajax config object
+Ajax.prototype.defaultConfig = {
+	method: "GET"
+};
+
+Ajax.prototype.defaultURLGenerator = function (url, config, params) {
+
+	if (url) {
+		if (params && Object.keys(params).length) {
+			if (!config.method || config.method.toLowerCase() == "get") {
+				config.method = "get";
+
+				url += (url.includes("?") ? "&" : "?") + this.modules.ajax.serializeParams(params);
+			}
+		}
+	}
+
+	return url;
+};
+
+Ajax.prototype.defaultLoaderPromise = function (url, config, params) {
+	var self = this,
+	    contentType;
+
+	return new Promise(function (resolve, reject) {
+
+		//set url
+		url = self.urlGenerator.call(self.table, url, config, params);
+
+		//set body content if not GET request
+		if (config.method.toUpperCase() != "GET") {
+			contentType = _typeof(self.table.options.ajaxContentType) === "object" ? self.table.options.ajaxContentType : self.contentTypeFormatters[self.table.options.ajaxContentType];
+			if (contentType) {
+
+				for (var key in contentType.headers) {
+					if (!config.headers) {
+						config.headers = {};
+					}
+
+					if (typeof config.headers[key] === "undefined") {
+						config.headers[key] = contentType.headers[key];
+					}
+				}
+
+				config.body = contentType.body.call(self, url, config, params);
+			} else {
+				console.warn("Ajax Error - Invalid ajaxContentType value:", self.table.options.ajaxContentType);
+			}
+		}
+
+		if (url) {
+
+			//configure headers
+			if (typeof config.headers === "undefined") {
+				config.headers = {};
+			}
+
+			if (typeof config.headers.Accept === "undefined") {
+				config.headers.Accept = "application/json";
+			}
+
+			if (typeof config.headers["X-Requested-With"] === "undefined") {
+				config.headers["X-Requested-With"] = "XMLHttpRequest";
+			}
+
+			if (typeof config.mode === "undefined") {
+				config.mode = "cors";
+			}
+
+			if (config.mode == "cors") {
+
+				if (typeof config.headers["Access-Control-Allow-Origin"] === "undefined") {
+					config.headers["Access-Control-Allow-Origin"] = window.location.origin;
+				}
+
+				if (typeof config.credentials === "undefined") {
+					config.credentials = 'same-origin';
+				}
+			} else {
+				if (typeof config.credentials === "undefined") {
+					config.credentials = 'include';
+				}
+			}
+
+			//send request
+			fetch(url, config).then(function (response) {
+				if (response.ok) {
+					response.json().then(function (data) {
+						resolve(data);
+					}).catch(function (error) {
+						reject(error);
+						console.warn("Ajax Load Error - Invalid JSON returned", error);
+					});
+				} else {
+					console.error("Ajax Load Error - Connection Error: " + response.status, response.statusText);
+					reject(response);
+				}
+			}).catch(function (error) {
+				console.error("Ajax Load Error - Connection Error: ", error);
+				reject(error);
+			});
+		} else {
+			console.warn("Ajax Load Error - No URL Set");
+			resolve([]);
+		}
+	});
+};
+
+Ajax.prototype.contentTypeFormatters = {
+	"json": {
+		headers: {
+			'Content-Type': 'application/json'
+		},
+		body: function body(url, config, params) {
+			return JSON.stringify(params);
+		}
+	},
+	"form": {
+		headers: {},
+		body: function body(url, config, params) {
+			var output = this.generateParamsList(params),
+			    form = new FormData();
+
+			output.forEach(function (item) {
+				form.append(item.key, item.value);
+			});
+
+			return form;
+		}
+	}
+};
+
+Tabulator.prototype.registerModule("ajax", Ajax);

public/assets/vendors/tabulator/js/modules/calculation_colums.js

@@ -0,0 +1,536 @@
+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; };
+
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+
+//public calc object
+var CalcComponent = function CalcComponent(row) {
+	this._row = row;
+};
+
+CalcComponent.prototype.getData = function (transform) {
+	return this._row.getData(transform);
+};
+
+CalcComponent.prototype.getElement = function () {
+	return this._row.getElement();
+};
+
+CalcComponent.prototype.getTable = function () {
+	return this._row.table;
+};
+
+CalcComponent.prototype.getCells = function () {
+	var cells = [];
+
+	this._row.getCells().forEach(function (cell) {
+		cells.push(cell.getComponent());
+	});
+
+	return cells;
+};
+
+CalcComponent.prototype.getCell = function (column) {
+	var cell = this._row.getCell(column);
+	return cell ? cell.getComponent() : false;
+};
+
+CalcComponent.prototype._getSelf = function () {
+	return this._row;
+};
+
+var ColumnCalcs = function ColumnCalcs(table) {
+	this.table = table; //hold Tabulator object
+	this.topCalcs = [];
+	this.botCalcs = [];
+	this.genColumn = false;
+	this.topElement = this.createElement();
+	this.botElement = this.createElement();
+	this.topRow = false;
+	this.botRow = false;
+	this.topInitialized = false;
+	this.botInitialized = false;
+
+	this.initialize();
+};
+
+ColumnCalcs.prototype.createElement = function () {
+	var el = document.createElement("div");
+	el.classList.add("tabulator-calcs-holder");
+	return el;
+};
+
+ColumnCalcs.prototype.initialize = function () {
+	this.genColumn = new Column({ field: "value" }, this);
+};
+
+//dummy functions to handle being mock column manager
+ColumnCalcs.prototype.registerColumnField = function () {};
+
+//initialize column calcs
+ColumnCalcs.prototype.initializeColumn = function (column) {
+	var def = column.definition;
+
+	var config = {
+		topCalcParams: def.topCalcParams || {},
+		botCalcParams: def.bottomCalcParams || {}
+	};
+
+	if (def.topCalc) {
+
+		switch (_typeof(def.topCalc)) {
+			case "string":
+				if (this.calculations[def.topCalc]) {
+					config.topCalc = this.calculations[def.topCalc];
+				} else {
+					console.warn("Column Calc Error - No such calculation found, ignoring: ", def.topCalc);
+				}
+				break;
+
+			case "function":
+				config.topCalc = def.topCalc;
+				break;
+
+		}
+
+		if (config.topCalc) {
+			column.modules.columnCalcs = config;
+			this.topCalcs.push(column);
+
+			if (this.table.options.columnCalcs != "group") {
+				this.initializeTopRow();
+			}
+		}
+	}
+
+	if (def.bottomCalc) {
+		switch (_typeof(def.bottomCalc)) {
+			case "string":
+				if (this.calculations[def.bottomCalc]) {
+					config.botCalc = this.calculations[def.bottomCalc];
+				} else {
+					console.warn("Column Calc Error - No such calculation found, ignoring: ", def.bottomCalc);
+				}
+				break;
+
+			case "function":
+				config.botCalc = def.bottomCalc;
+				break;
+
+		}
+
+		if (config.botCalc) {
+			column.modules.columnCalcs = config;
+			this.botCalcs.push(column);
+
+			if (this.table.options.columnCalcs != "group") {
+				this.initializeBottomRow();
+			}
+		}
+	}
+};
+
+ColumnCalcs.prototype.removeCalcs = function () {
+	var changed = false;
+
+	if (this.topInitialized) {
+		this.topInitialized = false;
+		this.topElement.parentNode.removeChild(this.topElement);
+		changed = true;
+	}
+
+	if (this.botInitialized) {
+		this.botInitialized = false;
+		this.table.footerManager.remove(this.botElement);
+		changed = true;
+	}
+
+	if (changed) {
+		this.table.rowManager.adjustTableSize();
+	}
+};
+
+ColumnCalcs.prototype.initializeTopRow = function () {
+	if (!this.topInitialized) {
+		this.table.columnManager.getElement().insertBefore(this.topElement, this.table.columnManager.headersElement.nextSibling);
+		this.topInitialized = true;
+	}
+};
+
+ColumnCalcs.prototype.initializeBottomRow = function () {
+	if (!this.botInitialized) {
+		this.table.footerManager.prepend(this.botElement);
+		this.botInitialized = true;
+	}
+};
+
+ColumnCalcs.prototype.scrollHorizontal = function (left) {
+	if (this.botInitialized && this.botRow) {
+		this.botRow.getElement().style.marginLeft = -left + "px";
+	}
+};
+
+ColumnCalcs.prototype.recalc = function (rows) {
+	var data, row;
+
+	if (this.topInitialized || this.botInitialized) {
+		data = this.rowsToData(rows);
+
+		if (this.topInitialized) {
+			if (this.topRow) {
+				this.topRow.deleteCells();
+			}
+
+			row = this.generateRow("top", this.rowsToData(rows));
+			this.topRow = row;
+			while (this.topElement.firstChild) {
+				this.topElement.removeChild(this.topElement.firstChild);
+			}this.topElement.appendChild(row.getElement());
+			row.initialize(true);
+		}
+
+		if (this.botInitialized) {
+			if (this.botRow) {
+				this.botRow.deleteCells();
+			}
+
+			row = this.generateRow("bottom", this.rowsToData(rows));
+			this.botRow = row;
+			while (this.botElement.firstChild) {
+				this.botElement.removeChild(this.botElement.firstChild);
+			}this.botElement.appendChild(row.getElement());
+			row.initialize(true);
+		}
+
+		this.table.rowManager.adjustTableSize();
+
+		//set resizable handles
+		if (this.table.modExists("frozenColumns")) {
+			this.table.modules.frozenColumns.layout();
+		}
+	}
+};
+
+ColumnCalcs.prototype.recalcRowGroup = function (row) {
+	this.recalcGroup(this.table.modules.groupRows.getRowGroup(row));
+};
+
+ColumnCalcs.prototype.recalcAll = function () {
+	var _this = this;
+
+	if (this.topCalcs.length || this.botCalcs.length) {
+		if (this.table.options.columnCalcs !== "group") {
+			this.recalc(this.table.rowManager.activeRows);
+		}
+
+		if (this.table.options.groupBy && this.table.options.columnCalcs !== "table") {
+
+			var groups = table.modules.groupRows.getChildGroups();
+
+			groups.forEach(function (group) {
+				_this.recalcGroup(group);
+			});
+		}
+	}
+};
+
+ColumnCalcs.prototype.recalcGroup = function (group) {
+	var data, rowData;
+
+	if (group) {
+		if (group.calcs) {
+			if (group.calcs.bottom) {
+				data = this.rowsToData(group.rows);
+				rowData = this.generateRowData("bottom", data);
+
+				group.calcs.bottom.updateData(rowData);
+				group.calcs.bottom.reinitialize();
+			}
+
+			if (group.calcs.top) {
+				data = this.rowsToData(group.rows);
+				rowData = this.generateRowData("top", data);
+
+				group.calcs.top.updateData(rowData);
+				group.calcs.top.reinitialize();
+			}
+		}
+	}
+};
+
+//generate top stats row
+ColumnCalcs.prototype.generateTopRow = function (rows) {
+	return this.generateRow("top", this.rowsToData(rows));
+};
+//generate bottom stats row
+ColumnCalcs.prototype.generateBottomRow = function (rows) {
+	return this.generateRow("bottom", this.rowsToData(rows));
+};
+
+ColumnCalcs.prototype.rowsToData = function (rows) {
+	var _this2 = this;
+
+	var data = [];
+
+	rows.forEach(function (row) {
+		data.push(row.getData());
+
+		if (_this2.table.options.dataTree && _this2.table.options.dataTreeChildColumnCalcs) {
+			if (row.modules.dataTree.open) {
+				var children = _this2.rowsToData(_this2.table.modules.dataTree.getFilteredTreeChildren(row));
+				data = data.concat(children);
+			}
+		}
+	});
+
+	return data;
+};
+
+//generate stats row
+ColumnCalcs.prototype.generateRow = function (pos, data) {
+	var self = this,
+	    rowData = this.generateRowData(pos, data),
+	    row;
+
+	if (self.table.modExists("mutator")) {
+		self.table.modules.mutator.disable();
+	}
+
+	row = new Row(rowData, this, "calc");
+
+	if (self.table.modExists("mutator")) {
+		self.table.modules.mutator.enable();
+	}
+
+	row.getElement().classList.add("tabulator-calcs", "tabulator-calcs-" + pos);
+
+	row.component = false;
+
+	row.getComponent = function () {
+		if (!this.component) {
+			this.component = new CalcComponent(this);
+		}
+
+		return this.component;
+	};
+
+	row.generateCells = function () {
+
+		var cells = [];
+
+		self.table.columnManager.columnsByIndex.forEach(function (column) {
+
+			//set field name of mock column
+			self.genColumn.setField(column.getField());
+			self.genColumn.hozAlign = column.hozAlign;
+
+			if (column.definition[pos + "CalcFormatter"] && self.table.modExists("format")) {
+				self.genColumn.modules.format = {
+					formatter: self.table.modules.format.getFormatter(column.definition[pos + "CalcFormatter"]),
+					params: column.definition[pos + "CalcFormatterParams"] || {}
+				};
+			} else {
+				self.genColumn.modules.format = {
+					formatter: self.table.modules.format.getFormatter("plaintext"),
+					params: {}
+				};
+			}
+
+			//ensure css class defintion is replicated to calculation cell
+			self.genColumn.definition.cssClass = column.definition.cssClass;
+
+			//generate cell and assign to correct column
+			var cell = new Cell(self.genColumn, row);
+			cell.getElement();
+			cell.column = column;
+			cell.setWidth();
+
+			column.cells.push(cell);
+			cells.push(cell);
+
+			if (!column.visible) {
+				cell.hide();
+			}
+		});
+
+		this.cells = cells;
+	};
+
+	return row;
+};
+
+//generate stats row
+ColumnCalcs.prototype.generateRowData = function (pos, data) {
+	var rowData = {},
+	    calcs = pos == "top" ? this.topCalcs : this.botCalcs,
+	    type = pos == "top" ? "topCalc" : "botCalc",
+	    params,
+	    paramKey;
+
+	calcs.forEach(function (column) {
+		var values = [];
+
+		if (column.modules.columnCalcs && column.modules.columnCalcs[type]) {
+			data.forEach(function (item) {
+				values.push(column.getFieldValue(item));
+			});
+
+			paramKey = type + "Params";
+			params = typeof column.modules.columnCalcs[paramKey] === "function" ? column.modules.columnCalcs[paramKey](values, data) : column.modules.columnCalcs[paramKey];
+
+			column.setFieldValue(rowData, column.modules.columnCalcs[type](values, data, params));
+		}
+	});
+
+	return rowData;
+};
+
+ColumnCalcs.prototype.hasTopCalcs = function () {
+	return !!this.topCalcs.length;
+};
+
+ColumnCalcs.prototype.hasBottomCalcs = function () {
+	return !!this.botCalcs.length;
+};
+
+//handle table redraw
+ColumnCalcs.prototype.redraw = function () {
+	if (this.topRow) {
+		this.topRow.normalizeHeight(true);
+	}
+	if (this.botRow) {
+		this.botRow.normalizeHeight(true);
+	}
+};
+
+//return the calculated
+ColumnCalcs.prototype.getResults = function () {
+	var self = this,
+	    results = {},
+	    groups;
+
+	if (this.table.options.groupBy && this.table.modExists("groupRows")) {
+		groups = this.table.modules.groupRows.getGroups(true);
+
+		groups.forEach(function (group) {
+			results[group.getKey()] = self.getGroupResults(group);
+		});
+	} else {
+		results = {
+			top: this.topRow ? this.topRow.getData() : {},
+			bottom: this.botRow ? this.botRow.getData() : {}
+		};
+	}
+
+	return results;
+};
+
+//get results from a group
+ColumnCalcs.prototype.getGroupResults = function (group) {
+	var self = this,
+	    groupObj = group._getSelf(),
+	    subGroups = group.getSubGroups(),
+	    subGroupResults = {},
+	    results = {};
+
+	subGroups.forEach(function (subgroup) {
+		subGroupResults[subgroup.getKey()] = self.getGroupResults(subgroup);
+	});
+
+	results = {
+		top: groupObj.calcs.top ? groupObj.calcs.top.getData() : {},
+		bottom: groupObj.calcs.bottom ? groupObj.calcs.bottom.getData() : {},
+		groups: subGroupResults
+	};
+
+	return results;
+};
+
+//default calculations
+ColumnCalcs.prototype.calculations = {
+	"avg": function avg(values, data, calcParams) {
+		var output = 0,
+		    precision = typeof calcParams.precision !== "undefined" ? calcParams.precision : 2;
+
+		if (values.length) {
+			output = values.reduce(function (sum, value) {
+				return Number(sum) + Number(value);
+			});
+
+			output = output / values.length;
+
+			output = precision !== false ? output.toFixed(precision) : output;
+		}
+
+		return parseFloat(output).toString();
+	},
+	"max": function max(values, data, calcParams) {
+		var output = null,
+		    precision = typeof calcParams.precision !== "undefined" ? calcParams.precision : false;
+
+		values.forEach(function (value) {
+
+			value = Number(value);
+
+			if (value > output || output === null) {
+				output = value;
+			}
+		});
+
+		return output !== null ? precision !== false ? output.toFixed(precision) : output : "";
+	},
+	"min": function min(values, data, calcParams) {
+		var output = null,
+		    precision = typeof calcParams.precision !== "undefined" ? calcParams.precision : false;
+
+		values.forEach(function (value) {
+
+			value = Number(value);
+
+			if (value < output || output === null) {
+				output = value;
+			}
+		});
+
+		return output !== null ? precision !== false ? output.toFixed(precision) : output : "";
+	},
+	"sum": function sum(values, data, calcParams) {
+		var output = 0,
+		    precision = typeof calcParams.precision !== "undefined" ? calcParams.precision : false;
+
+		if (values.length) {
+			values.forEach(function (value) {
+				value = Number(value);
+
+				output += !isNaN(value) ? Number(value) : 0;
+			});
+		}
+
+		return precision !== false ? output.toFixed(precision) : output;
+	},
+	"concat": function concat(values, data, calcParams) {
+		var output = 0;
+
+		if (values.length) {
+			output = values.reduce(function (sum, value) {
+				return String(sum) + String(value);
+			});
+		}
+
+		return output;
+	},
+	"count": function count(values, data, calcParams) {
+		var output = 0;
+
+		if (values.length) {
+			values.forEach(function (value) {
+				if (value) {
+					output++;
+				}
+			});
+		}
+
+		return output;
+	}
+};
+
+Tabulator.prototype.registerModule("columnCalcs", ColumnCalcs);

public/assets/vendors/tabulator/js/modules/clipboard.js

@@ -0,0 +1,349 @@
+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; };
+
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+
+var Clipboard = function Clipboard(table) {
+	this.table = table;
+	this.mode = true;
+
+	this.pasteParser = function () {};
+	this.pasteAction = function () {};
+	this.customSelection = false;
+	this.rowRange = false;
+	this.blocked = true; //block copy actions not originating from this command
+};
+
+Clipboard.prototype.initialize = function () {
+	var _this = this;
+
+	this.mode = this.table.options.clipboard;
+
+	this.rowRange = this.table.options.clipboardCopyRowRange;
+
+	if (this.mode === true || this.mode === "copy") {
+		this.table.element.addEventListener("copy", function (e) {
+			var plain, html, list;
+
+			if (!_this.blocked) {
+				e.preventDefault();
+
+				if (_this.customSelection) {
+					plain = _this.customSelection;
+
+					if (_this.table.options.clipboardCopyFormatter) {
+						plain = _this.table.options.clipboardCopyFormatter("plain", plain);
+					}
+				} else {
+
+					var list = _this.table.modules.export.generateExportList(_this.table.options.clipboardCopyConfig, _this.table.options.clipboardCopyStyled, _this.rowRange, "clipboard");
+
+					html = _this.table.modules.export.genereateHTMLTable(list);
+					plain = html ? _this.generatePlainContent(list) : "";
+
+					if (_this.table.options.clipboardCopyFormatter) {
+						plain = _this.table.options.clipboardCopyFormatter("plain", plain);
+						html = _this.table.options.clipboardCopyFormatter("html", html);
+					}
+				}
+
+				if (window.clipboardData && window.clipboardData.setData) {
+					window.clipboardData.setData('Text', plain);
+				} else if (e.clipboardData && e.clipboardData.setData) {
+					e.clipboardData.setData('text/plain', plain);
+					if (html) {
+						e.clipboardData.setData('text/html', html);
+					}
+				} else if (e.originalEvent && e.originalEvent.clipboardData.setData) {
+					e.originalEvent.clipboardData.setData('text/plain', plain);
+					if (html) {
+						e.originalEvent.clipboardData.setData('text/html', html);
+					}
+				}
+
+				_this.table.options.clipboardCopied.call(_this.table, plain, html);
+
+				_this.reset();
+			}
+		});
+	}
+
+	if (this.mode === true || this.mode === "paste") {
+		this.table.element.addEventListener("paste", function (e) {
+			_this.paste(e);
+		});
+	}
+
+	this.setPasteParser(this.table.options.clipboardPasteParser);
+	this.setPasteAction(this.table.options.clipboardPasteAction);
+};
+
+Clipboard.prototype.reset = function () {
+	this.blocked = true;
+	this.customSelection = false;
+};
+
+Clipboard.prototype.generatePlainContent = function (list) {
+	var output = [];
+
+	list.forEach(function (row) {
+		var rowData = [];
+
+		row.columns.forEach(function (col) {
+			var value = "";
+
+			if (col) {
+
+				if (row.type === "group") {
+					col.value = col.component.getKey();
+				}
+
+				if (col.value === null) {
+					value = "";
+				} else {
+					switch (_typeof(col.value)) {
+						case "object":
+							value = JSON.stringify(col.value);
+							break;
+
+						case "undefined":
+							value = "";
+							break;
+
+						default:
+							value = col.value;
+					}
+				}
+			}
+
+			rowData.push(value);
+		});
+
+		output.push(rowData.join("\t"));
+	});
+
+	return output.join("\n");
+};
+
+Clipboard.prototype.copy = function (range, internal) {
+	var range, sel, textRange;
+	this.blocked = false;
+	this.customSelection = false;
+
+	if (this.mode === true || this.mode === "copy") {
+
+		this.rowRange = range || this.table.options.clipboardCopyRowRange;
+
+		if (typeof window.getSelection != "undefined" && typeof document.createRange != "undefined") {
+			range = document.createRange();
+			range.selectNodeContents(this.table.element);
+			sel = window.getSelection();
+
+			if (sel.toString() && internal) {
+				this.customSelection = sel.toString();
+			}
+
+			sel.removeAllRanges();
+			sel.addRange(range);
+		} else if (typeof document.selection != "undefined" && typeof document.body.createTextRange != "undefined") {
+			textRange = document.body.createTextRange();
+			textRange.moveToElementText(this.table.element);
+			textRange.select();
+		}
+
+		document.execCommand('copy');
+
+		if (sel) {
+			sel.removeAllRanges();
+		}
+	}
+};
+
+//PASTE EVENT HANDLING
+
+Clipboard.prototype.setPasteAction = function (action) {
+
+	switch (typeof action === "undefined" ? "undefined" : _typeof(action)) {
+		case "string":
+			this.pasteAction = this.pasteActions[action];
+
+			if (!this.pasteAction) {
+				console.warn("Clipboard Error - No such paste action found:", action);
+			}
+			break;
+
+		case "function":
+			this.pasteAction = action;
+			break;
+	}
+};
+
+Clipboard.prototype.setPasteParser = function (parser) {
+	switch (typeof parser === "undefined" ? "undefined" : _typeof(parser)) {
+		case "string":
+			this.pasteParser = this.pasteParsers[parser];
+
+			if (!this.pasteParser) {
+				console.warn("Clipboard Error - No such paste parser found:", parser);
+			}
+			break;
+
+		case "function":
+			this.pasteParser = parser;
+			break;
+	}
+};
+
+Clipboard.prototype.paste = function (e) {
+	var data, rowData, rows;
+
+	if (this.checkPaseOrigin(e)) {
+
+		data = this.getPasteData(e);
+
+		rowData = this.pasteParser.call(this, data);
+
+		if (rowData) {
+			e.preventDefault();
+
+			if (this.table.modExists("mutator")) {
+				rowData = this.mutateData(rowData);
+			}
+
+			rows = this.pasteAction.call(this, rowData);
+			this.table.options.clipboardPasted.call(this.table, data, rowData, rows);
+		} else {
+			this.table.options.clipboardPasteError.call(this.table, data);
+		}
+	}
+};
+
+Clipboard.prototype.mutateData = function (data) {
+	var self = this,
+	    output = [];
+
+	if (Array.isArray(data)) {
+		data.forEach(function (row) {
+			output.push(self.table.modules.mutator.transformRow(row, "clipboard"));
+		});
+	} else {
+		output = data;
+	}
+
+	return output;
+};
+
+Clipboard.prototype.checkPaseOrigin = function (e) {
+	var valid = true;
+
+	if (e.target.tagName != "DIV" || this.table.modules.edit.currentCell) {
+		valid = false;
+	}
+
+	return valid;
+};
+
+Clipboard.prototype.getPasteData = function (e) {
+	var data;
+
+	if (window.clipboardData && window.clipboardData.getData) {
+		data = window.clipboardData.getData('Text');
+	} else if (e.clipboardData && e.clipboardData.getData) {
+		data = e.clipboardData.getData('text/plain');
+	} else if (e.originalEvent && e.originalEvent.clipboardData.getData) {
+		data = e.originalEvent.clipboardData.getData('text/plain');
+	}
+
+	return data;
+};
+
+Clipboard.prototype.pasteParsers = {
+	table: function table(clipboard) {
+		var data = [],
+		    success = false,
+		    headerFindSuccess = true,
+		    columns = this.table.columnManager.columns,
+		    columnMap = [],
+		    rows = [];
+
+		//get data from clipboard into array of columns and rows.
+		clipboard = clipboard.split("\n");
+
+		clipboard.forEach(function (row) {
+			data.push(row.split("\t"));
+		});
+
+		if (data.length && !(data.length === 1 && data[0].length < 2)) {
+			success = true;
+
+			//check if headers are present by title
+			data[0].forEach(function (value) {
+				var column = columns.find(function (column) {
+					return value && column.definition.title && value.trim() && column.definition.title.trim() === value.trim();
+				});
+
+				if (column) {
+					columnMap.push(column);
+				} else {
+					headerFindSuccess = false;
+				}
+			});
+
+			//check if column headers are present by field
+			if (!headerFindSuccess) {
+				headerFindSuccess = true;
+				columnMap = [];
+
+				data[0].forEach(function (value) {
+					var column = columns.find(function (column) {
+						return value && column.field && value.trim() && column.field.trim() === value.trim();
+					});
+
+					if (column) {
+						columnMap.push(column);
+					} else {
+						headerFindSuccess = false;
+					}
+				});
+
+				if (!headerFindSuccess) {
+					columnMap = this.table.columnManager.columnsByIndex;
+				}
+			}
+
+			//remove header row if found
+			if (headerFindSuccess) {
+				data.shift();
+			}
+
+			data.forEach(function (item) {
+				var row = {};
+
+				item.forEach(function (value, i) {
+					if (columnMap[i]) {
+						row[columnMap[i].field] = value;
+					}
+				});
+
+				rows.push(row);
+			});
+
+			return rows;
+		} else {
+			return false;
+		}
+	}
+};
+
+Clipboard.prototype.pasteActions = {
+	replace: function replace(rows) {
+		return this.table.setData(rows);
+	},
+	update: function update(rows) {
+		return this.table.updateOrAddData(rows);
+	},
+	insert: function insert(rows) {
+		return this.table.addData(rows);
+	}
+};
+
+Tabulator.prototype.registerModule("clipboard", Clipboard);

public/assets/vendors/tabulator/js/modules/data_tree.js

@@ -0,0 +1,515 @@
+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; };
+
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+
+var DataTree = function DataTree(table) {
+	this.table = table;
+	this.indent = 10;
+	this.field = "";
+	this.collapseEl = null;
+	this.expandEl = null;
+	this.branchEl = null;
+	this.elementField = false;
+
+	this.startOpen = function () {};
+
+	this.displayIndex = 0;
+};
+
+DataTree.prototype.initialize = function () {
+	var dummyEl = null,
+	    firstCol = this.table.columnManager.getFirstVisibileColumn(),
+	    options = this.table.options;
+
+	this.field = options.dataTreeChildField;
+	this.indent = options.dataTreeChildIndent;
+	this.elementField = options.dataTreeElementColumn || (firstCol ? firstCol.field : false);
+
+	if (options.dataTreeBranchElement) {
+
+		if (options.dataTreeBranchElement === true) {
+			this.branchEl = document.createElement("div");
+			this.branchEl.classList.add("tabulator-data-tree-branch");
+		} else {
+			if (typeof options.dataTreeBranchElement === "string") {
+				dummyEl = document.createElement("div");
+				dummyEl.innerHTML = options.dataTreeBranchElement;
+				this.branchEl = dummyEl.firstChild;
+			} else {
+				this.branchEl = options.dataTreeBranchElement;
+			}
+		}
+	}
+
+	if (options.dataTreeCollapseElement) {
+		if (typeof options.dataTreeCollapseElement === "string") {
+			dummyEl = document.createElement("div");
+			dummyEl.innerHTML = options.dataTreeCollapseElement;
+			this.collapseEl = dummyEl.firstChild;
+		} else {
+			this.collapseEl = options.dataTreeCollapseElement;
+		}
+	} else {
+		this.collapseEl = document.createElement("div");
+		this.collapseEl.classList.add("tabulator-data-tree-control");
+		this.collapseEl.tabIndex = 0;
+		this.collapseEl.innerHTML = "<div class='tabulator-data-tree-control-collapse'></div>";
+	}
+
+	if (options.dataTreeExpandElement) {
+		if (typeof options.dataTreeExpandElement === "string") {
+			dummyEl = document.createElement("div");
+			dummyEl.innerHTML = options.dataTreeExpandElement;
+			this.expandEl = dummyEl.firstChild;
+		} else {
+			this.expandEl = options.dataTreeExpandElement;
+		}
+	} else {
+		this.expandEl = document.createElement("div");
+		this.expandEl.classList.add("tabulator-data-tree-control");
+		this.expandEl.tabIndex = 0;
+		this.expandEl.innerHTML = "<div class='tabulator-data-tree-control-expand'></div>";
+	}
+
+	switch (_typeof(options.dataTreeStartExpanded)) {
+		case "boolean":
+			this.startOpen = function (row, index) {
+				return options.dataTreeStartExpanded;
+			};
+			break;
+
+		case "function":
+			this.startOpen = options.dataTreeStartExpanded;
+			break;
+
+		default:
+			this.startOpen = function (row, index) {
+				return options.dataTreeStartExpanded[index];
+			};
+			break;
+	}
+};
+
+DataTree.prototype.initializeRow = function (row) {
+	var childArray = row.getData()[this.field];
+	var isArray = Array.isArray(childArray);
+
+	var children = isArray || !isArray && (typeof childArray === "undefined" ? "undefined" : _typeof(childArray)) === "object" && childArray !== null;
+
+	if (!children && row.modules.dataTree && row.modules.dataTree.branchEl) {
+		row.modules.dataTree.branchEl.parentNode.removeChild(row.modules.dataTree.branchEl);
+	}
+
+	if (!children && row.modules.dataTree && row.modules.dataTree.controlEl) {
+		row.modules.dataTree.controlEl.parentNode.removeChild(row.modules.dataTree.controlEl);
+	}
+
+	row.modules.dataTree = {
+		index: row.modules.dataTree ? row.modules.dataTree.index : 0,
+		open: children ? row.modules.dataTree ? row.modules.dataTree.open : this.startOpen(row.getComponent(), 0) : false,
+		controlEl: row.modules.dataTree && children ? row.modules.dataTree.controlEl : false,
+		branchEl: row.modules.dataTree && children ? row.modules.dataTree.branchEl : false,
+		parent: row.modules.dataTree ? row.modules.dataTree.parent : false,
+		children: children
+	};
+};
+
+DataTree.prototype.layoutRow = function (row) {
+	var cell = this.elementField ? row.getCell(this.elementField) : row.getCells()[0],
+	    el = cell.getElement(),
+	    config = row.modules.dataTree;
+
+	if (config.branchEl) {
+		if (config.branchEl.parentNode) {
+			config.branchEl.parentNode.removeChild(config.branchEl);
+		}
+		config.branchEl = false;
+	}
+
+	if (config.controlEl) {
+		if (config.controlEl.parentNode) {
+			config.controlEl.parentNode.removeChild(config.controlEl);
+		}
+		config.controlEl = false;
+	}
+
+	this.generateControlElement(row, el);
+
+	row.getElement().classList.add("tabulator-tree-level-" + config.index);
+
+	if (config.index) {
+		if (this.branchEl) {
+			config.branchEl = this.branchEl.cloneNode(true);
+			el.insertBefore(config.branchEl, el.firstChild);
+
+			if (this.table.rtl) {
+				config.branchEl.style.marginRight = (config.branchEl.offsetWidth + config.branchEl.style.marginLeft) * (config.index - 1) + config.index * this.indent + "px";
+			} else {
+				config.branchEl.style.marginLeft = (config.branchEl.offsetWidth + config.branchEl.style.marginRight) * (config.index - 1) + config.index * this.indent + "px";
+			}
+		} else {
+
+			if (this.table.rtl) {
+				el.style.paddingRight = parseInt(window.getComputedStyle(el, null).getPropertyValue('padding-right')) + config.index * this.indent + "px";
+			} else {
+				el.style.paddingLeft = parseInt(window.getComputedStyle(el, null).getPropertyValue('padding-left')) + config.index * this.indent + "px";
+			}
+		}
+	}
+};
+
+DataTree.prototype.generateControlElement = function (row, el) {
+	var _this = this;
+
+	var config = row.modules.dataTree,
+	    el = el || row.getCells()[0].getElement(),
+	    oldControl = config.controlEl;
+
+	if (config.children !== false) {
+
+		if (config.open) {
+			config.controlEl = this.collapseEl.cloneNode(true);
+			config.controlEl.addEventListener("click", function (e) {
+				e.stopPropagation();
+				_this.collapseRow(row);
+			});
+		} else {
+			config.controlEl = this.expandEl.cloneNode(true);
+			config.controlEl.addEventListener("click", function (e) {
+				e.stopPropagation();
+				_this.expandRow(row);
+			});
+		}
+
+		config.controlEl.addEventListener("mousedown", function (e) {
+			e.stopPropagation();
+		});
+
+		if (oldControl && oldControl.parentNode === el) {
+			oldControl.parentNode.replaceChild(config.controlEl, oldControl);
+		} else {
+			el.insertBefore(config.controlEl, el.firstChild);
+		}
+	}
+};
+
+DataTree.prototype.setDisplayIndex = function (index) {
+	this.displayIndex = index;
+};
+
+DataTree.prototype.getDisplayIndex = function () {
+	return this.displayIndex;
+};
+
+DataTree.prototype.getRows = function (rows) {
+	var _this2 = this;
+
+	var output = [];
+
+	rows.forEach(function (row, i) {
+		var config, children;
+
+		output.push(row);
+
+		if (row instanceof Row) {
+
+			row.create();
+
+			config = row.modules.dataTree.children;
+
+			if (!config.index && config.children !== false) {
+				children = _this2.getChildren(row);
+
+				children.forEach(function (child) {
+					child.create();
+					output.push(child);
+				});
+			}
+		}
+	});
+
+	return output;
+};
+
+DataTree.prototype.getChildren = function (row, allChildren) {
+	var _this3 = this;
+
+	var config = row.modules.dataTree,
+	    children = [],
+	    output = [];
+
+	if (config.children !== false && (config.open || allChildren)) {
+		if (!Array.isArray(config.children)) {
+			config.children = this.generateChildren(row);
+		}
+
+		if (this.table.modExists("filter") && this.table.options.dataTreeFilter) {
+			children = this.table.modules.filter.filter(config.children);
+		} else {
+			children = config.children;
+		}
+
+		if (this.table.modExists("sort") && this.table.options.dataTreeSort) {
+			this.table.modules.sort.sort(children);
+		}
+
+		children.forEach(function (child) {
+			output.push(child);
+
+			var subChildren = _this3.getChildren(child);
+
+			subChildren.forEach(function (sub) {
+				output.push(sub);
+			});
+		});
+	}
+
+	return output;
+};
+
+DataTree.prototype.generateChildren = function (row) {
+	var _this4 = this;
+
+	var children = [];
+
+	var childArray = row.getData()[this.field];
+
+	if (!Array.isArray(childArray)) {
+		childArray = [childArray];
+	}
+
+	childArray.forEach(function (childData) {
+		var childRow = new Row(childData || {}, _this4.table.rowManager);
+
+		childRow.create();
+
+		childRow.modules.dataTree.index = row.modules.dataTree.index + 1;
+		childRow.modules.dataTree.parent = row;
+
+		if (childRow.modules.dataTree.children) {
+			childRow.modules.dataTree.open = _this4.startOpen(childRow.getComponent(), childRow.modules.dataTree.index);
+		}
+		children.push(childRow);
+	});
+
+	return children;
+};
+
+DataTree.prototype.expandRow = function (row, silent) {
+	var config = row.modules.dataTree;
+
+	if (config.children !== false) {
+		config.open = true;
+
+		row.reinitialize();
+
+		this.table.rowManager.refreshActiveData("tree", false, true);
+
+		this.table.options.dataTreeRowExpanded(row.getComponent(), row.modules.dataTree.index);
+	}
+};
+
+DataTree.prototype.collapseRow = function (row) {
+	var config = row.modules.dataTree;
+
+	if (config.children !== false) {
+		config.open = false;
+
+		row.reinitialize();
+
+		this.table.rowManager.refreshActiveData("tree", false, true);
+
+		this.table.options.dataTreeRowCollapsed(row.getComponent(), row.modules.dataTree.index);
+	}
+};
+
+DataTree.prototype.toggleRow = function (row) {
+	var config = row.modules.dataTree;
+
+	if (config.children !== false) {
+		if (config.open) {
+			this.collapseRow(row);
+		} else {
+			this.expandRow(row);
+		}
+	}
+};
+
+DataTree.prototype.getTreeParent = function (row) {
+	return row.modules.dataTree.parent ? row.modules.dataTree.parent.getComponent() : false;
+};
+
+DataTree.prototype.getFilteredTreeChildren = function (row) {
+	var config = row.modules.dataTree,
+	    output = [],
+	    children;
+
+	if (config.children) {
+
+		if (!Array.isArray(config.children)) {
+			config.children = this.generateChildren(row);
+		}
+
+		if (this.table.modExists("filter") && this.table.options.dataTreeFilter) {
+			children = this.table.modules.filter.filter(config.children);
+		} else {
+			children = config.children;
+		}
+
+		children.forEach(function (childRow) {
+			if (childRow instanceof Row) {
+				output.push(childRow);
+			}
+		});
+	}
+
+	return output;
+};
+
+DataTree.prototype.rowDelete = function (row) {
+	var parent = row.modules.dataTree.parent,
+	    childIndex;
+
+	if (parent) {
+		childIndex = this.findChildIndex(row, parent);
+
+		if (childIndex !== false) {
+			parent.data[this.field].splice(childIndex, 1);
+		}
+
+		if (!parent.data[this.field].length) {
+			delete parent.data[this.field];
+		}
+
+		this.initializeRow(parent);
+		this.layoutRow(parent);
+	}
+
+	this.table.rowManager.refreshActiveData("tree", false, true);
+};
+
+DataTree.prototype.addTreeChildRow = function (row, data, top, index) {
+	var childIndex = false;
+
+	if (typeof data === "string") {
+		data = JSON.parse(data);
+	}
+
+	if (!Array.isArray(row.data[this.field])) {
+		row.data[this.field] = [];
+
+		row.modules.dataTree.open = this.startOpen(row.getComponent(), row.modules.dataTree.index);
+	}
+
+	if (typeof index !== "undefined") {
+		childIndex = this.findChildIndex(index, row);
+
+		if (childIndex !== false) {
+			row.data[this.field].splice(top ? childIndex : childIndex + 1, 0, data);
+		}
+	}
+
+	if (childIndex === false) {
+		if (top) {
+			row.data[this.field].unshift(data);
+		} else {
+			row.data[this.field].push(data);
+		}
+	}
+
+	this.initializeRow(row);
+	this.layoutRow(row);
+
+	this.table.rowManager.refreshActiveData("tree", false, true);
+};
+
+DataTree.prototype.findChildIndex = function (subject, parent) {
+	var _this5 = this;
+
+	var match = false;
+
+	if ((typeof subject === "undefined" ? "undefined" : _typeof(subject)) == "object") {
+
+		if (subject instanceof Row) {
+			//subject is row element
+			match = subject.data;
+		} else if (subject instanceof RowComponent) {
+			//subject is public row component
+			match = subject._getSelf().data;
+		} else if (typeof HTMLElement !== "undefined" && subject instanceof HTMLElement) {
+			if (parent.modules.dataTree) {
+				match = parent.modules.dataTree.children.find(function (childRow) {
+					return childRow instanceof Row ? childRow.element === subject : false;
+				});
+
+				if (match) {
+					match = match.data;
+				}
+			}
+		}
+	} else if (typeof subject == "undefined" || subject === null) {
+		match = false;
+	} else {
+		//subject should be treated as the index of the row
+		match = parent.data[this.field].find(function (row) {
+			return row.data[_this5.table.options.index] == subject;
+		});
+	}
+
+	if (match) {
+
+		if (Array.isArray(parent.data[this.field])) {
+			match = parent.data[this.field].indexOf(match);
+		}
+
+		if (match == -1) {
+			match = false;
+		}
+	}
+
+	//catch all for any other type of input
+
+	return match;
+};
+
+DataTree.prototype.getTreeChildren = function (row, component, recurse) {
+	var _this6 = this;
+
+	var config = row.modules.dataTree,
+	    output = [];
+
+	if (config.children) {
+
+		if (!Array.isArray(config.children)) {
+			config.children = this.generateChildren(row);
+		}
+
+		config.children.forEach(function (childRow) {
+			if (childRow instanceof Row) {
+				output.push(component ? childRow.getComponent() : childRow);
+
+				if (recurse) {
+					output = output.concat(_this6.getTreeChildren(childRow, component, recurse));
+				}
+			}
+		});
+	}
+
+	return output;
+};
+
+DataTree.prototype.checkForRestyle = function (cell) {
+	if (!cell.row.cells.indexOf(cell)) {
+		cell.row.reinitialize();
+	}
+};
+
+DataTree.prototype.getChildField = function () {
+	return this.field;
+};
+
+DataTree.prototype.redrawNeeded = function (data) {
+	return (this.field ? typeof data[this.field] !== "undefined" : false) || (this.elementField ? typeof data[this.elementField] !== "undefined" : false);
+};
+
+Tabulator.prototype.registerModule("dataTree", DataTree);

public/assets/vendors/tabulator/js/modules/download.js

@@ -0,0 +1,433 @@
+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; };
+
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+
+var Download = function Download(table) {
+	this.table = table; //hold Tabulator object
+};
+
+//trigger file download
+Download.prototype.download = function (type, filename, options, range, interceptCallback) {
+	var self = this,
+	    downloadFunc = false;
+
+	function buildLink(data, mime) {
+		if (interceptCallback) {
+			if (interceptCallback === true) {
+				self.triggerDownload(data, mime, type, filename, true);
+			} else {
+				interceptCallback(data);
+			}
+		} else {
+			self.triggerDownload(data, mime, type, filename);
+		}
+	}
+
+	if (typeof type == "function") {
+		downloadFunc = type;
+	} else {
+		if (self.downloaders[type]) {
+			downloadFunc = self.downloaders[type];
+		} else {
+			console.warn("Download Error - No such download type found: ", type);
+		}
+	}
+
+	if (downloadFunc) {
+		var list = this.generateExportList(range);
+
+		downloadFunc.call(this.table, list, options || {}, buildLink);
+	}
+};
+
+Download.prototype.generateExportList = function (range) {
+	var list = this.table.modules.export.generateExportList(this.table.options.downloadConfig, false, range || this.table.options.downloadRowRange, "download");
+
+	//assign group header formatter
+	var groupHeader = this.table.options.groupHeaderDownload;
+
+	if (groupHeader && !Array.isArray(groupHeader)) {
+		groupHeader = [groupHeader];
+	}
+
+	list.forEach(function (row) {
+		var group;
+
+		if (row.type === "group") {
+			group = row.columns[0];
+
+			if (groupHeader && groupHeader[row.indent]) {
+				group.value = groupHeader[row.indent](group.value, row.component._group.getRowCount(), row.component._group.getData(), row.component);
+			}
+		}
+	});
+
+	return list;
+};
+
+Download.prototype.triggerDownload = function (data, mime, type, filename, newTab) {
+	var element = document.createElement('a'),
+	    blob = new Blob([data], { type: mime }),
+	    filename = filename || "Tabulator." + (typeof type === "function" ? "txt" : type);
+
+	blob = this.table.options.downloadReady.call(this.table, data, blob);
+
+	if (blob) {
+
+		if (newTab) {
+			window.open(window.URL.createObjectURL(blob));
+		} else {
+			if (navigator.msSaveOrOpenBlob) {
+				navigator.msSaveOrOpenBlob(blob, filename);
+			} else {
+				element.setAttribute('href', window.URL.createObjectURL(blob));
+
+				//set file title
+				element.setAttribute('download', filename);
+
+				//trigger download
+				element.style.display = 'none';
+				document.body.appendChild(element);
+				element.click();
+
+				//remove temporary link element
+				document.body.removeChild(element);
+			}
+		}
+
+		if (this.table.options.downloadComplete) {
+			this.table.options.downloadComplete();
+		}
+	}
+};
+
+Download.prototype.commsReceived = function (table, action, data) {
+	switch (action) {
+		case "intercept":
+			this.download(data.type, "", data.options, data.active, data.intercept);
+			break;
+	}
+};
+
+//downloaders
+Download.prototype.downloaders = {
+	csv: function csv(list, options, setFileContents) {
+		var delimiter = options && options.delimiter ? options.delimiter : ",",
+		    fileContents = [],
+		    headers = [];
+
+		list.forEach(function (row) {
+			var item = [];
+
+			switch (row.type) {
+				case "group":
+					console.warn("Download Warning - CSV downloader cannot process row groups");
+					break;
+
+				case "calc":
+					console.warn("Download Warning - CSV downloader cannot process column calculations");
+					break;
+
+				case "header":
+					row.columns.forEach(function (col, i) {
+						if (col && col.depth === 1) {
+							headers[i] = typeof col.value == "undefined" || col.value === null ? "" : '"' + String(col.value).split('"').join('""') + '"';
+						}
+					});
+					break;
+
+				case "row":
+					row.columns.forEach(function (col) {
+
+						if (col) {
+
+							switch (_typeof(col.value)) {
+								case "object":
+									col.value = JSON.stringify(col.value);
+									break;
+
+								case "undefined":
+								case "null":
+									col.value = "";
+									break;
+							}
+
+							item.push('"' + String(col.value).split('"').join('""') + '"');
+						}
+					});
+
+					fileContents.push(item.join(delimiter));
+					break;
+			}
+		});
+
+		if (headers.length) {
+			fileContents.unshift(headers.join(delimiter));
+		}
+
+		fileContents = fileContents.join("\n");
+
+		if (options.bom) {
+			fileContents = "\uFEFF" + fileContents;
+		}
+
+		setFileContents(fileContents, "text/csv");
+	},
+
+	json: function json(list, options, setFileContents) {
+		var fileContents = [];
+
+		list.forEach(function (row) {
+			var item = {};
+
+			switch (row.type) {
+				case "header":
+					break;
+
+				case "group":
+					console.warn("Download Warning - JSON downloader cannot process row groups");
+					break;
+
+				case "calc":
+					console.warn("Download Warning - JSON downloader cannot process column calculations");
+					break;
+
+				case "row":
+					row.columns.forEach(function (col) {
+						if (col) {
+							item[col.component.getField()] = col.value;
+						}
+					});
+
+					fileContents.push(item);
+					break;
+			}
+		});
+
+		fileContents = JSON.stringify(fileContents, null, '\t');
+
+		setFileContents(fileContents, "application/json");
+	},
+
+	pdf: function pdf(list, options, setFileContents) {
+		var header = [],
+		    body = [],
+		    autoTableParams = {},
+		    rowGroupStyles = options.rowGroupStyles || {
+			fontStyle: "bold",
+			fontSize: 12,
+			cellPadding: 6,
+			fillColor: 220
+		},
+		    rowCalcStyles = options.rowCalcStyles || {
+			fontStyle: "bold",
+			fontSize: 10,
+			cellPadding: 4,
+			fillColor: 232
+		},
+		    jsPDFParams = options.jsPDF || {},
+		    title = options && options.title ? options.title : "";
+
+		if (!jsPDFParams.orientation) {
+			jsPDFParams.orientation = options.orientation || "landscape";
+		}
+
+		if (!jsPDFParams.unit) {
+			jsPDFParams.unit = "pt";
+		}
+
+		//parse row list
+		list.forEach(function (row) {
+			var item = {};
+
+			switch (row.type) {
+				case "header":
+					header.push(parseRow(row));
+					break;
+
+				case "group":
+					body.push(parseRow(row, rowGroupStyles));
+					break;
+
+				case "calc":
+					body.push(parseRow(row, rowCalcStyles));
+					break;
+
+				case "row":
+					body.push(parseRow(row));
+					break;
+			}
+		});
+
+		function parseRow(row, styles) {
+			var rowData = [];
+
+			row.columns.forEach(function (col) {
+				var cell;
+
+				if (col) {
+					switch (_typeof(col.value)) {
+						case "object":
+							col.value = JSON.stringify(col.value);
+							break;
+
+						case "undefined":
+						case "null":
+							col.value = "";
+							break;
+					}
+
+					cell = {
+						content: col.value,
+						colSpan: col.width,
+						rowSpan: col.height
+					};
+
+					if (styles) {
+						cell.styles = styles;
+					}
+
+					rowData.push(cell);
+				} else {
+					rowData.push("");
+				}
+			});
+
+			return rowData;
+		}
+
+		//configure PDF
+		var doc = new jsPDF(jsPDFParams); //set document to landscape, better for most tables
+
+		if (options && options.autoTable) {
+			if (typeof options.autoTable === "function") {
+				autoTableParams = options.autoTable(doc) || {};
+			} else {
+				autoTableParams = options.autoTable;
+			}
+		}
+
+		if (title) {
+			autoTableParams.addPageContent = function (data) {
+				doc.text(title, 40, 30);
+			};
+		}
+
+		autoTableParams.head = header;
+		autoTableParams.body = body;
+
+		doc.autoTable(autoTableParams);
+
+		if (options && options.documentProcessing) {
+			options.documentProcessing(doc);
+		}
+
+		setFileContents(doc.output("arraybuffer"), "application/pdf");
+	},
+
+	xlsx: function xlsx(list, options, setFileContents) {
+		var self = this,
+		    sheetName = options.sheetName || "Sheet1",
+		    workbook = XLSX.utils.book_new(),
+		    output;
+
+		workbook.SheetNames = [];
+		workbook.Sheets = {};
+
+		function generateSheet() {
+			var rows = [],
+			    merges = [],
+			    worksheet = {},
+			    range = { s: { c: 0, r: 0 }, e: { c: list[0] ? list[0].columns.reduce(function (a, b) {
+						return a + (b && b.width ? b.width : 1);
+					}, 0) : 0, r: list.length } };
+
+			//parse row list
+			list.forEach(function (row, i) {
+				var rowData = [];
+
+				row.columns.forEach(function (col, j) {
+
+					if (col) {
+						rowData.push(!(col.value instanceof Date) && _typeof(col.value) === "object" ? JSON.stringify(col.value) : col.value);
+
+						if (col.width > 1 || col.height > -1) {
+							merges.push({ s: { r: i, c: j }, e: { r: i + col.height - 1, c: j + col.width - 1 } });
+						}
+					} else {
+						rowData.push("");
+					}
+				});
+
+				rows.push(rowData);
+			});
+
+			//convert rows to worksheet
+			XLSX.utils.sheet_add_aoa(worksheet, rows);
+
+			worksheet['!ref'] = XLSX.utils.encode_range(range);
+
+			if (merges.length) {
+				worksheet["!merges"] = merges;
+			}
+
+			return worksheet;
+		}
+
+		if (options.sheetOnly) {
+			setFileContents(generateSheet());
+			return;
+		}
+
+		if (options.sheets) {
+			for (var sheet in options.sheets) {
+
+				if (options.sheets[sheet] === true) {
+					workbook.SheetNames.push(sheet);
+					workbook.Sheets[sheet] = generateSheet();
+				} else {
+
+					workbook.SheetNames.push(sheet);
+
+					this.modules.comms.send(options.sheets[sheet], "download", "intercept", {
+						type: "xlsx",
+						options: { sheetOnly: true },
+						active: self.active,
+						intercept: function intercept(data) {
+							workbook.Sheets[sheet] = data;
+						}
+					});
+				}
+			}
+		} else {
+			workbook.SheetNames.push(sheetName);
+			workbook.Sheets[sheetName] = generateSheet();
+		}
+
+		if (options.documentProcessing) {
+			workbook = options.documentProcessing(workbook);
+		}
+
+		//convert workbook to binary array
+		function s2ab(s) {
+			var buf = new ArrayBuffer(s.length);
+			var view = new Uint8Array(buf);
+			for (var i = 0; i != s.length; ++i) {
+				view[i] = s.charCodeAt(i) & 0xFF;
+			}return buf;
+		}
+
+		output = XLSX.write(workbook, { bookType: 'xlsx', bookSST: true, type: 'binary' });
+
+		setFileContents(s2ab(output), "application/octet-stream");
+	},
+
+	html: function html(list, options, setFileContents) {
+		if (this.modExists("export", true)) {
+			setFileContents(this.modules.export.genereateHTMLTable(list), "text/html");
+		}
+	}
+
+};
+
+Tabulator.prototype.registerModule("download", Download);

public/assets/vendors/tabulator/js/modules/export.js

@@ -0,0 +1,614 @@
+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; };
+
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+
+var ExportRow = function ExportRow(type, columns, component, indent) {
+	this.type = type;
+	this.columns = columns;
+	this.component = component || false;
+	this.indent = indent || 0;
+};
+
+var ExportColumn = function ExportColumn(value, component, width, height, depth) {
+	this.value = value;
+	this.component = component || false;
+	this.width = width;
+	this.height = height;
+	this.depth = depth;
+};
+
+var Export = function Export(table) {
+	this.table = table; //hold Tabulator object
+	this.config = {};
+	this.cloneTableStyle = true;
+	this.colVisProp = "";
+};
+
+Export.prototype.generateExportList = function (config, style, range, colVisProp) {
+	this.cloneTableStyle = style;
+	this.config = config || {};
+	this.colVisProp = colVisProp;
+
+	var headers = this.config.columnHeaders !== false ? this.headersToExportRows(this.generateColumnGroupHeaders()) : [];
+	var body = this.bodyToExportRows(this.rowLookup(range));
+
+	return headers.concat(body);
+};
+
+Export.prototype.genereateTable = function (config, style, range, colVisProp) {
+	var list = this.generateExportList(config, style, range, colVisProp);
+
+	return this.genereateTableElement(list);
+};
+
+Export.prototype.rowLookup = function (range) {
+	var _this = this;
+
+	var rows = [];
+
+	if (typeof range == "function") {
+		range.call(this.table).forEach(function (row) {
+			row = _this.table.rowManager.findRow(row);
+
+			if (row) {
+				rows.push(row);
+			}
+		});
+	} else {
+		switch (range) {
+			case true:
+			case "visible":
+				rows = this.table.rowManager.getVisibleRows(true);
+				break;
+
+			case "all":
+				rows = this.table.rowManager.rows;
+				break;
+
+			case "selected":
+				rows = this.table.modules.selectRow.selectedRows;
+				break;
+
+			case "active":
+			default:
+				if (this.table.options.pagination) {
+					rows = this.table.rowManager.getDisplayRows(this.table.rowManager.displayRows.length - 2);
+				} else {
+					rows = this.table.rowManager.getDisplayRows();
+				}
+		}
+	}
+
+	return Object.assign([], rows);
+};
+
+Export.prototype.generateColumnGroupHeaders = function () {
+	var _this2 = this;
+
+	var output = [];
+
+	var columns = this.config.columnGroups !== false ? this.table.columnManager.columns : this.table.columnManager.columnsByIndex;
+
+	columns.forEach(function (column) {
+		var colData = _this2.processColumnGroup(column);
+
+		if (colData) {
+			output.push(colData);
+		}
+	});
+
+	return output;
+};
+
+Export.prototype.processColumnGroup = function (column) {
+	var _this3 = this;
+
+	var subGroups = column.columns,
+	    maxDepth = 0,
+	    title = column.definition["title" + (this.colVisProp.charAt(0).toUpperCase() + this.colVisProp.slice(1))] || column.definition.title;
+
+	var groupData = {
+		title: title,
+		column: column,
+		depth: 1
+	};
+
+	if (subGroups.length) {
+		groupData.subGroups = [];
+		groupData.width = 0;
+
+		subGroups.forEach(function (subGroup) {
+			var subGroupData = _this3.processColumnGroup(subGroup);
+
+			if (subGroupData) {
+				groupData.width += subGroupData.width;
+				groupData.subGroups.push(subGroupData);
+
+				if (subGroupData.depth > maxDepth) {
+					maxDepth = subGroupData.depth;
+				}
+			}
+		});
+
+		groupData.depth += maxDepth;
+
+		if (!groupData.width) {
+			return false;
+		}
+	} else {
+		if (this.columnVisCheck(column)) {
+			groupData.width = 1;
+		} else {
+			return false;
+		}
+	}
+
+	return groupData;
+};
+
+Export.prototype.columnVisCheck = function (column) {
+	return column.definition[this.colVisProp] !== false && (column.visible || !column.visible && column.definition[this.colVisProp]);
+};
+
+Export.prototype.headersToExportRows = function (columns) {
+	var headers = [],
+	    headerDepth = 0,
+	    exportRows = [];
+
+	function parseColumnGroup(column, level) {
+
+		var depth = headerDepth - level;
+
+		if (typeof headers[level] === "undefined") {
+			headers[level] = [];
+		}
+
+		column.height = column.subGroups ? 1 : depth - column.depth + 1;
+
+		headers[level].push(column);
+
+		if (column.height > 1) {
+			for (var _i = 1; _i < column.height; _i++) {
+
+				if (typeof headers[level + _i] === "undefined") {
+					headers[level + _i] = [];
+				}
+
+				headers[level + _i].push(false);
+			}
+		}
+
+		if (column.width > 1) {
+			for (var _i2 = 1; _i2 < column.width; _i2++) {
+				headers[level].push(false);
+			}
+		}
+
+		if (column.subGroups) {
+			column.subGroups.forEach(function (subGroup) {
+				parseColumnGroup(subGroup, level + 1);
+			});
+		}
+	}
+
+	//calculate maximum header debth
+	columns.forEach(function (column) {
+		if (column.depth > headerDepth) {
+			headerDepth = column.depth;
+		}
+	});
+
+	columns.forEach(function (column) {
+		parseColumnGroup(column, 0);
+	});
+
+	headers.forEach(function (header) {
+		var columns = [];
+
+		header.forEach(function (col) {
+			if (col) {
+				columns.push(new ExportColumn(col.title, col.column.getComponent(), col.width, col.height, col.depth));
+			} else {
+				columns.push(null);
+			}
+		});
+
+		exportRows.push(new ExportRow("header", columns));
+	});
+
+	return exportRows;
+};
+
+Export.prototype.bodyToExportRows = function (rows) {
+	var _this4 = this;
+
+	var columns = [];
+	var exportRows = [];
+
+	this.table.columnManager.columnsByIndex.forEach(function (column) {
+		if (_this4.columnVisCheck(column)) {
+			columns.push(column.getComponent());
+		}
+	});
+
+	if (this.config.columnCalcs !== false && this.table.modExists("columnCalcs")) {
+		if (this.table.modules.columnCalcs.topInitialized) {
+			rows.unshift(this.table.modules.columnCalcs.topRow);
+		}
+
+		if (this.table.modules.columnCalcs.botInitialized) {
+			rows.push(this.table.modules.columnCalcs.botRow);
+		}
+	}
+
+	rows = rows.filter(function (row) {
+		switch (row.type) {
+			case "group":
+				return _this4.config.rowGroups !== false;
+				break;
+
+			case "calc":
+				return _this4.config.columnCalcs !== false;
+				break;
+
+			case "row":
+				return !(_this4.table.options.dataTree && _this4.config.dataTree === false && row.modules.dataTree.parent);
+				break;
+		}
+
+		return true;
+	});
+
+	rows.forEach(function (row, i) {
+		var rowData = row.getData(_this4.colVisProp);
+		var exportCols = [];
+		var indent = 0;
+
+		switch (row.type) {
+			case "group":
+				indent = row.level;
+				exportCols.push(new ExportColumn(row.key, row.getComponent(), columns.length, 1));
+				break;
+
+			case "calc":
+			case "row":
+				columns.forEach(function (col) {
+					exportCols.push(new ExportColumn(col._column.getFieldValue(rowData), col, 1, 1));
+				});
+
+				if (_this4.table.options.dataTree && _this4.config.dataTree !== false) {
+					indent = row.modules.dataTree.index;
+				}
+				break;
+		}
+
+		exportRows.push(new ExportRow(row.type, exportCols, row.getComponent(), indent));
+	});
+
+	return exportRows;
+};
+
+Export.prototype.genereateTableElement = function (list) {
+	var _this5 = this;
+
+	var table = document.createElement("table"),
+	    headerEl = document.createElement("thead"),
+	    bodyEl = document.createElement("tbody"),
+	    styles = this.lookupTableStyles(),
+	    rowFormatter = this.table.options["rowFormatter" + (this.colVisProp.charAt(0).toUpperCase() + this.colVisProp.slice(1))],
+	    setup = {};
+
+	setup.rowFormatter = rowFormatter !== null ? rowFormatter : this.table.options.rowFormatter;
+
+	if (this.table.options.dataTree && this.config.dataTree !== false && this.table.modExists("columnCalcs")) {
+		setup.treeElementField = this.table.modules.dataTree.elementField;
+	}
+
+	//assign group header formatter
+	setup.groupHeader = this.table.options["groupHeader" + (this.colVisProp.charAt(0).toUpperCase() + this.colVisProp.slice(1))];
+
+	if (setup.groupHeader && !Array.isArray(setup.groupHeader)) {
+		setup.groupHeader = [setup.groupHeader];
+	}
+
+	table.classList.add("tabulator-print-table");
+
+	this.mapElementStyles(this.table.columnManager.getHeadersElement(), headerEl, ["border-top", "border-left", "border-right", "border-bottom", "background-color", "color", "font-weight", "font-family", "font-size"]);
+
+	if (list.length > 1000) {
+		console.warn("It may take a long time to render an HTML table with more than 1000 rows");
+	}
+
+	list.forEach(function (row, i) {
+		switch (row.type) {
+			case "header":
+				headerEl.appendChild(_this5.genereateHeaderElement(row, setup, styles));
+				break;
+
+			case "group":
+				bodyEl.appendChild(_this5.genereateGroupElement(row, setup, styles));
+				break;
+
+			case "calc":
+				bodyEl.appendChild(_this5.genereateCalcElement(row, setup, styles));
+				break;
+
+			case "row":
+				var rowEl = _this5.genereateRowElement(row, setup, styles);
+				_this5.mapElementStyles(i % 2 && styles.evenRow ? styles.evenRow : styles.oddRow, rowEl, ["border-top", "border-left", "border-right", "border-bottom", "color", "font-weight", "font-family", "font-size", "background-color"]);
+				bodyEl.appendChild(rowEl);
+				break;
+		}
+	});
+
+	if (headerEl.innerHTML) {
+		table.appendChild(headerEl);
+	}
+
+	table.appendChild(bodyEl);
+
+	this.mapElementStyles(this.table.element, table, ["border-top", "border-left", "border-right", "border-bottom"]);
+	return table;
+};
+
+Export.prototype.lookupTableStyles = function () {
+	var styles = {};
+
+	//lookup row styles
+	if (this.cloneTableStyle && window.getComputedStyle) {
+		styles.oddRow = this.table.element.querySelector(".tabulator-row-odd:not(.tabulator-group):not(.tabulator-calcs)");
+		styles.evenRow = this.table.element.querySelector(".tabulator-row-even:not(.tabulator-group):not(.tabulator-calcs)");
+		styles.calcRow = this.table.element.querySelector(".tabulator-row.tabulator-calcs");
+		styles.firstRow = this.table.element.querySelector(".tabulator-row:not(.tabulator-group):not(.tabulator-calcs)");
+		styles.firstGroup = this.table.element.getElementsByClassName("tabulator-group")[0];
+
+		if (styles.firstRow) {
+			styles.styleCells = styles.firstRow.getElementsByClassName("tabulator-cell");
+			styles.firstCell = styles.styleCells[0];
+			styles.lastCell = styles.styleCells[styles.styleCells.length - 1];
+		}
+	}
+
+	return styles;
+};
+
+Export.prototype.genereateHeaderElement = function (row, setup, styles) {
+	var _this6 = this;
+
+	var rowEl = document.createElement("tr");
+
+	row.columns.forEach(function (column) {
+		if (column) {
+			var cellEl = document.createElement("th");
+			var classNames = column.component._column.definition.cssClass ? column.component._column.definition.cssClass.split(" ") : [];
+
+			cellEl.colSpan = column.width;
+			cellEl.rowSpan = column.height;
+
+			cellEl.innerHTML = column.value;
+
+			if (_this6.cloneTableStyle) {
+				cellEl.style.boxSizing = "border-box";
+			}
+
+			classNames.forEach(function (className) {
+				cellEl.classList.add(className);
+			});
+
+			_this6.mapElementStyles(column.component.getElement(), cellEl, ["text-align", "border-top", "border-left", "border-right", "border-bottom", "background-color", "color", "font-weight", "font-family", "font-size"]);
+			_this6.mapElementStyles(column.component._column.contentElement, cellEl, ["padding-top", "padding-left", "padding-right", "padding-bottom"]);
+
+			if (column.component._column.visible) {
+				_this6.mapElementStyles(column.component.getElement(), cellEl, ["width"]);
+			} else {
+				if (column.component._column.definition.width) {
+					cellEl.style.width = column.component._column.definition.width + "px";
+				}
+			}
+
+			if (column.component._column.parent) {
+				_this6.mapElementStyles(column.component._column.parent.groupElement, cellEl, ["border-top"]);
+			}
+
+			rowEl.appendChild(cellEl);
+		}
+	});
+
+	return rowEl;
+};
+
+Export.prototype.genereateGroupElement = function (row, setup, styles) {
+
+	var rowEl = document.createElement("tr"),
+	    cellEl = document.createElement("td"),
+	    group = row.columns[0];
+
+	rowEl.classList.add("tabulator-print-table-row");
+
+	if (setup.groupHeader && setup.groupHeader[row.indent]) {
+		group.value = setup.groupHeader[row.indent](group.value, row.component._group.getRowCount(), row.component._group.getData(), row.component);
+	} else {
+		if (setup.groupHeader === false) {
+			group.value = group.value;
+		} else {
+			group.value = row.component._group.generator(group.value, row.component._group.getRowCount(), row.component._group.getData(), row.component);
+		}
+	}
+
+	cellEl.colSpan = group.width;
+	cellEl.innerHTML = group.value;
+
+	rowEl.classList.add("tabulator-print-table-group");
+	rowEl.classList.add("tabulator-group-level-" + row.indent);
+
+	if (group.component.isVisible()) {
+		rowEl.classList.add("tabulator-group-visible");
+	}
+
+	this.mapElementStyles(styles.firstGroup, rowEl, ["border-top", "border-left", "border-right", "border-bottom", "color", "font-weight", "font-family", "font-size", "background-color"]);
+	this.mapElementStyles(styles.firstGroup, cellEl, ["padding-top", "padding-left", "padding-right", "padding-bottom"]);
+
+	rowEl.appendChild(cellEl);
+
+	return rowEl;
+};
+
+Export.prototype.genereateCalcElement = function (row, setup, styles) {
+	var rowEl = this.genereateRowElement(row, setup, styles);
+
+	rowEl.classList.add("tabulator-print-table-calcs");
+	this.mapElementStyles(styles.calcRow, rowEl, ["border-top", "border-left", "border-right", "border-bottom", "color", "font-weight", "font-family", "font-size", "background-color"]);
+
+	return rowEl;
+};
+
+Export.prototype.genereateRowElement = function (row, setup, styles) {
+	var _this7 = this;
+
+	var rowEl = document.createElement("tr");
+
+	rowEl.classList.add("tabulator-print-table-row");
+
+	row.columns.forEach(function (col) {
+
+		if (col) {
+			var cellEl = document.createElement("td"),
+			    column = col.component._column,
+			    value = col.value;
+
+			var cellWrapper = {
+				modules: {},
+				getValue: function getValue() {
+					return value;
+				},
+				getField: function getField() {
+					return column.definition.field;
+				},
+				getElement: function getElement() {
+					return cellEl;
+				},
+				getColumn: function getColumn() {
+					return column.getComponent();
+				},
+				getData: function getData() {
+					return row.component.getData();
+				},
+				getRow: function getRow() {
+					return row.component;
+				},
+				getComponent: function getComponent() {
+					return cellWrapper;
+				},
+				column: column
+			};
+
+			var classNames = column.definition.cssClass ? column.definition.cssClass.split(" ") : [];
+
+			classNames.forEach(function (className) {
+				cellEl.classList.add(className);
+			});
+
+			if (_this7.table.modExists("format") && _this7.config.formatCells !== false) {
+				value = _this7.table.modules.format.formatExportValue(cellWrapper, _this7.colVisProp);
+			} else {
+				switch (typeof value === "undefined" ? "undefined" : _typeof(value)) {
+					case "object":
+						value = JSON.stringify(value);
+						break;
+
+					case "undefined":
+					case "null":
+						value = "";
+						break;
+
+					default:
+						value = value;
+				}
+			}
+
+			if (value instanceof Node) {
+				cellEl.appendChild(value);
+			} else {
+				cellEl.innerHTML = value;
+			}
+
+			if (styles.firstCell) {
+				_this7.mapElementStyles(styles.firstCell, cellEl, ["padding-top", "padding-left", "padding-right", "padding-bottom", "border-top", "border-left", "border-right", "border-bottom", "color", "font-weight", "font-family", "font-size"]);
+
+				if (column.definition.align) {
+					cellEl.style.textAlign = column.definition.align;
+				}
+			}
+
+			if (_this7.table.options.dataTree && _this7.config.dataTree !== false) {
+				if (setup.treeElementField && setup.treeElementField == column.field || !setup.treeElementField && i == 0) {
+					if (row.component._row.modules.dataTree.controlEl) {
+						cellEl.insertBefore(row.component._row.modules.dataTree.controlEl.cloneNode(true), cellEl.firstChild);
+					}
+					if (row.component._row.modules.dataTree.branchEl) {
+						cellEl.insertBefore(row.component._row.modules.dataTree.branchEl.cloneNode(true), cellEl.firstChild);
+					}
+				}
+			}
+
+			rowEl.appendChild(cellEl);
+
+			if (cellWrapper.modules.format && cellWrapper.modules.format.renderedCallback) {
+				cellWrapper.modules.format.renderedCallback();
+			}
+
+			if (setup.rowFormatter && _this7.config.formatCells !== false) {
+				setup.rowFormatter(row.component);
+			}
+		}
+	});
+
+	return rowEl;
+};
+
+Export.prototype.genereateHTMLTable = function (list) {
+	var holder = document.createElement("div");
+
+	holder.appendChild(this.genereateTableElement(list));
+
+	return holder.innerHTML;
+};
+
+Export.prototype.getHtml = function (visible, style, config, colVisProp) {
+	var list = this.generateExportList(config || this.table.options.htmlOutputConfig, style, visible, colVisProp || "htmlOutput");
+
+	return this.genereateHTMLTable(list);
+};
+
+Export.prototype.mapElementStyles = function (from, to, props) {
+	if (this.cloneTableStyle && from && to) {
+
+		var lookup = {
+			"background-color": "backgroundColor",
+			"color": "fontColor",
+			"width": "width",
+			"font-weight": "fontWeight",
+			"font-family": "fontFamily",
+			"font-size": "fontSize",
+			"text-align": "textAlign",
+			"border-top": "borderTop",
+			"border-left": "borderLeft",
+			"border-right": "borderRight",
+			"border-bottom": "borderBottom",
+			"padding-top": "paddingTop",
+			"padding-left": "paddingLeft",
+			"padding-right": "paddingRight",
+			"padding-bottom": "paddingBottom"
+		};
+
+		if (window.getComputedStyle) {
+			var fromStyle = window.getComputedStyle(from);
+
+			props.forEach(function (prop) {
+				to.style[lookup[prop]] = fromStyle.getPropertyValue(prop);
+			});
+		}
+	}
+};
+
+Tabulator.prototype.registerModule("export", Export);

public/assets/vendors/tabulator/js/modules/filter.js

@@ -0,0 +1,809 @@
+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; };
+
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+
+var Filter = function Filter(table) {
+
+	this.table = table; //hold Tabulator object
+
+	this.filterList = []; //hold filter list
+	this.headerFilters = {}; //hold column filters
+	this.headerFilterColumns = []; //hold columns that use header filters
+
+	this.prevHeaderFilterChangeCheck = "";
+	this.prevHeaderFilterChangeCheck = "{}";
+
+	this.changed = false; //has filtering changed since last render
+};
+
+//initialize column header filter
+Filter.prototype.initializeColumn = function (column, value) {
+	var self = this,
+	    field = column.getField(),
+	    params;
+
+	//handle successfull value change
+	function success(value) {
+		var filterType = column.modules.filter.tagType == "input" && column.modules.filter.attrType == "text" || column.modules.filter.tagType == "textarea" ? "partial" : "match",
+		    type = "",
+		    filterChangeCheck = "",
+		    filterFunc;
+
+		if (typeof column.modules.filter.prevSuccess === "undefined" || column.modules.filter.prevSuccess !== value) {
+
+			column.modules.filter.prevSuccess = value;
+
+			if (!column.modules.filter.emptyFunc(value)) {
+				column.modules.filter.value = value;
+
+				switch (_typeof(column.definition.headerFilterFunc)) {
+					case "string":
+						if (self.filters[column.definition.headerFilterFunc]) {
+							type = column.definition.headerFilterFunc;
+							filterFunc = function filterFunc(data) {
+								var params = column.definition.headerFilterFuncParams || {};
+								var fieldVal = column.getFieldValue(data);
+
+								params = typeof params === "function" ? params(value, fieldVal, data) : params;
+
+								return self.filters[column.definition.headerFilterFunc](value, fieldVal, data, params);
+							};
+						} else {
+							console.warn("Header Filter Error - Matching filter function not found: ", column.definition.headerFilterFunc);
+						}
+						break;
+
+					case "function":
+						filterFunc = function filterFunc(data) {
+							var params = column.definition.headerFilterFuncParams || {};
+							var fieldVal = column.getFieldValue(data);
+
+							params = typeof params === "function" ? params(value, fieldVal, data) : params;
+
+							return column.definition.headerFilterFunc(value, fieldVal, data, params);
+						};
+
+						type = filterFunc;
+						break;
+				}
+
+				if (!filterFunc) {
+					switch (filterType) {
+						case "partial":
+							filterFunc = function filterFunc(data) {
+								var colVal = column.getFieldValue(data);
+
+								if (typeof colVal !== 'undefined' && colVal !== null) {
+									return String(colVal).toLowerCase().indexOf(String(value).toLowerCase()) > -1;
+								} else {
+									return false;
+								}
+							};
+							type = "like";
+							break;
+
+						default:
+							filterFunc = function filterFunc(data) {
+								return column.getFieldValue(data) == value;
+							};
+							type = "=";
+					}
+				}
+
+				self.headerFilters[field] = { value: value, func: filterFunc, type: type, params: params || {} };
+			} else {
+				delete self.headerFilters[field];
+			}
+
+			filterChangeCheck = JSON.stringify(self.headerFilters);
+
+			if (self.prevHeaderFilterChangeCheck !== filterChangeCheck) {
+				self.prevHeaderFilterChangeCheck = filterChangeCheck;
+
+				self.changed = true;
+				self.table.rowManager.filterRefresh();
+			}
+		}
+
+		return true;
+	}
+
+	column.modules.filter = {
+		success: success,
+		attrType: false,
+		tagType: false,
+		emptyFunc: false
+	};
+
+	this.generateHeaderFilterElement(column);
+};
+
+Filter.prototype.generateHeaderFilterElement = function (column, initialValue, reinitialize) {
+	var _this = this;
+
+	var self = this,
+	    success = column.modules.filter.success,
+	    field = column.getField(),
+	    filterElement,
+	    editor,
+	    editorElement,
+	    cellWrapper,
+	    typingTimer,
+	    searchTrigger,
+	    params;
+
+	//handle aborted edit
+	function cancel() {}
+
+	if (column.modules.filter.headerElement && column.modules.filter.headerElement.parentNode) {
+		column.contentElement.removeChild(column.modules.filter.headerElement.parentNode);
+	}
+
+	if (field) {
+
+		//set empty value function
+		column.modules.filter.emptyFunc = column.definition.headerFilterEmptyCheck || function (value) {
+			return !value && value !== "0" && value !== 0;
+		};
+
+		filterElement = document.createElement("div");
+		filterElement.classList.add("tabulator-header-filter");
+
+		//set column editor
+		switch (_typeof(column.definition.headerFilter)) {
+			case "string":
+				if (self.table.modules.edit.editors[column.definition.headerFilter]) {
+					editor = self.table.modules.edit.editors[column.definition.headerFilter];
+
+					if ((column.definition.headerFilter === "tick" || column.definition.headerFilter === "tickCross") && !column.definition.headerFilterEmptyCheck) {
+						column.modules.filter.emptyFunc = function (value) {
+							return value !== true && value !== false;
+						};
+					}
+				} else {
+					console.warn("Filter Error - Cannot build header filter, No such editor found: ", column.definition.editor);
+				}
+				break;
+
+			case "function":
+				editor = column.definition.headerFilter;
+				break;
+
+			case "boolean":
+				if (column.modules.edit && column.modules.edit.editor) {
+					editor = column.modules.edit.editor;
+				} else {
+					if (column.definition.formatter && self.table.modules.edit.editors[column.definition.formatter]) {
+						editor = self.table.modules.edit.editors[column.definition.formatter];
+
+						if ((column.definition.formatter === "tick" || column.definition.formatter === "tickCross") && !column.definition.headerFilterEmptyCheck) {
+							column.modules.filter.emptyFunc = function (value) {
+								return value !== true && value !== false;
+							};
+						}
+					} else {
+						editor = self.table.modules.edit.editors["input"];
+					}
+				}
+				break;
+		}
+
+		if (editor) {
+
+			cellWrapper = {
+				getValue: function getValue() {
+					return typeof initialValue !== "undefined" ? initialValue : "";
+				},
+				getField: function getField() {
+					return column.definition.field;
+				},
+				getElement: function getElement() {
+					return filterElement;
+				},
+				getColumn: function getColumn() {
+					return column.getComponent();
+				},
+				getRow: function getRow() {
+					return {
+						normalizeHeight: function normalizeHeight() {}
+					};
+				}
+			};
+
+			params = column.definition.headerFilterParams || {};
+
+			params = typeof params === "function" ? params.call(self.table) : params;
+
+			editorElement = editor.call(this.table.modules.edit, cellWrapper, function () {}, success, cancel, params);
+
+			if (!editorElement) {
+				console.warn("Filter Error - Cannot add filter to " + field + " column, editor returned a value of false");
+				return;
+			}
+
+			if (!(editorElement instanceof Node)) {
+				console.warn("Filter Error - Cannot add filter to " + field + " column, editor should return an instance of Node, the editor returned:", editorElement);
+				return;
+			}
+
+			//set Placeholder Text
+			if (field) {
+				self.table.modules.localize.bind("headerFilters|columns|" + column.definition.field, function (value) {
+					editorElement.setAttribute("placeholder", typeof value !== "undefined" && value ? value : self.table.modules.localize.getText("headerFilters|default"));
+				});
+			} else {
+				self.table.modules.localize.bind("headerFilters|default", function (value) {
+					editorElement.setAttribute("placeholder", typeof self.column.definition.headerFilterPlaceholder !== "undefined" && self.column.definition.headerFilterPlaceholder ? self.column.definition.headerFilterPlaceholder : value);
+				});
+			}
+
+			//focus on element on click
+			editorElement.addEventListener("click", function (e) {
+				e.stopPropagation();
+				editorElement.focus();
+			});
+
+			editorElement.addEventListener("focus", function (e) {
+				var left = _this.table.columnManager.element.scrollLeft;
+
+				if (left !== _this.table.rowManager.element.scrollLeft) {
+					_this.table.rowManager.scrollHorizontal(left);
+					_this.table.columnManager.scrollHorizontal(left);
+				}
+			});
+
+			//live update filters as user types
+			typingTimer = false;
+
+			searchTrigger = function searchTrigger(e) {
+				if (typingTimer) {
+					clearTimeout(typingTimer);
+				}
+
+				typingTimer = setTimeout(function () {
+					success(editorElement.value);
+				}, self.table.options.headerFilterLiveFilterDelay);
+			};
+
+			column.modules.filter.headerElement = editorElement;
+			column.modules.filter.attrType = editorElement.hasAttribute("type") ? editorElement.getAttribute("type").toLowerCase() : "";
+			column.modules.filter.tagType = editorElement.tagName.toLowerCase();
+
+			if (column.definition.headerFilterLiveFilter !== false) {
+
+				if (!(column.definition.headerFilter === 'autocomplete' || column.definition.headerFilter === 'tickCross' || (column.definition.editor === 'autocomplete' || column.definition.editor === 'tickCross') && column.definition.headerFilter === true)) {
+					editorElement.addEventListener("keyup", searchTrigger);
+					editorElement.addEventListener("search", searchTrigger);
+
+					//update number filtered columns on change
+					if (column.modules.filter.attrType == "number") {
+						editorElement.addEventListener("change", function (e) {
+							success(editorElement.value);
+						});
+					}
+
+					//change text inputs to search inputs to allow for clearing of field
+					if (column.modules.filter.attrType == "text" && this.table.browser !== "ie") {
+						editorElement.setAttribute("type", "search");
+						// editorElement.off("change blur"); //prevent blur from triggering filter and preventing selection click
+					}
+				}
+
+				//prevent input and select elements from propegating click to column sorters etc
+				if (column.modules.filter.tagType == "input" || column.modules.filter.tagType == "select" || column.modules.filter.tagType == "textarea") {
+					editorElement.addEventListener("mousedown", function (e) {
+						e.stopPropagation();
+					});
+				}
+			}
+
+			filterElement.appendChild(editorElement);
+
+			column.contentElement.appendChild(filterElement);
+
+			if (!reinitialize) {
+				self.headerFilterColumns.push(column);
+			}
+		}
+	} else {
+		console.warn("Filter Error - Cannot add header filter, column has no field set:", column.definition.title);
+	}
+};
+
+//hide all header filter elements (used to ensure correct column widths in "fitData" layout mode)
+Filter.prototype.hideHeaderFilterElements = function () {
+	this.headerFilterColumns.forEach(function (column) {
+		if (column.modules.filter && column.modules.filter.headerElement) {
+			column.modules.filter.headerElement.style.display = 'none';
+		}
+	});
+};
+
+//show all header filter elements (used to ensure correct column widths in "fitData" layout mode)
+Filter.prototype.showHeaderFilterElements = function () {
+	this.headerFilterColumns.forEach(function (column) {
+		if (column.modules.filter && column.modules.filter.headerElement) {
+			column.modules.filter.headerElement.style.display = '';
+		}
+	});
+};
+
+//programatically set focus of header filter
+Filter.prototype.setHeaderFilterFocus = function (column) {
+	if (column.modules.filter && column.modules.filter.headerElement) {
+		column.modules.filter.headerElement.focus();
+	} else {
+		console.warn("Column Filter Focus Error - No header filter set on column:", column.getField());
+	}
+};
+
+//programmatically get value of header filter
+Filter.prototype.getHeaderFilterValue = function (column) {
+	if (column.modules.filter && column.modules.filter.headerElement) {
+		return column.modules.filter.headerElement.value;
+	} else {
+		console.warn("Column Filter Error - No header filter set on column:", column.getField());
+	}
+};
+
+//programatically set value of header filter
+Filter.prototype.setHeaderFilterValue = function (column, value) {
+	if (column) {
+		if (column.modules.filter && column.modules.filter.headerElement) {
+			this.generateHeaderFilterElement(column, value, true);
+			column.modules.filter.success(value);
+		} else {
+			console.warn("Column Filter Error - No header filter set on column:", column.getField());
+		}
+	}
+};
+
+Filter.prototype.reloadHeaderFilter = function (column) {
+	if (column) {
+		if (column.modules.filter && column.modules.filter.headerElement) {
+			this.generateHeaderFilterElement(column, column.modules.filter.value, true);
+		} else {
+			console.warn("Column Filter Error - No header filter set on column:", column.getField());
+		}
+	}
+};
+
+//check if the filters has changed since last use
+Filter.prototype.hasChanged = function () {
+	var changed = this.changed;
+	this.changed = false;
+	return changed;
+};
+
+//set standard filters
+Filter.prototype.setFilter = function (field, type, value, params) {
+	var self = this;
+
+	self.filterList = [];
+
+	if (!Array.isArray(field)) {
+		field = [{ field: field, type: type, value: value, params: params }];
+	}
+
+	self.addFilter(field);
+};
+
+//add filter to array
+Filter.prototype.addFilter = function (field, type, value, params) {
+	var self = this;
+
+	if (!Array.isArray(field)) {
+		field = [{ field: field, type: type, value: value, params: params }];
+	}
+
+	field.forEach(function (filter) {
+
+		filter = self.findFilter(filter);
+
+		if (filter) {
+			self.filterList.push(filter);
+
+			self.changed = true;
+		}
+	});
+
+	if (this.table.options.persistence && this.table.modExists("persistence", true) && this.table.modules.persistence.config.filter) {
+		this.table.modules.persistence.save("filter");
+	}
+};
+
+Filter.prototype.findFilter = function (filter) {
+	var self = this,
+	    column;
+
+	if (Array.isArray(filter)) {
+		return this.findSubFilters(filter);
+	}
+
+	var filterFunc = false;
+
+	if (typeof filter.field == "function") {
+		filterFunc = function filterFunc(data) {
+			return filter.field(data, filter.type || {}); // pass params to custom filter function
+		};
+	} else {
+
+		if (self.filters[filter.type]) {
+
+			column = self.table.columnManager.getColumnByField(filter.field);
+
+			if (column) {
+				filterFunc = function filterFunc(data) {
+					return self.filters[filter.type](filter.value, column.getFieldValue(data), data, filter.params || {});
+				};
+			} else {
+				filterFunc = function filterFunc(data) {
+					return self.filters[filter.type](filter.value, data[filter.field], data, filter.params || {});
+				};
+			}
+		} else {
+			console.warn("Filter Error - No such filter type found, ignoring: ", filter.type);
+		}
+	}
+
+	filter.func = filterFunc;
+
+	return filter.func ? filter : false;
+};
+
+Filter.prototype.findSubFilters = function (filters) {
+	var self = this,
+	    output = [];
+
+	filters.forEach(function (filter) {
+		filter = self.findFilter(filter);
+
+		if (filter) {
+			output.push(filter);
+		}
+	});
+
+	return output.length ? output : false;
+};
+
+//get all filters
+Filter.prototype.getFilters = function (all, ajax) {
+	var output = [];
+
+	if (all) {
+		output = this.getHeaderFilters();
+	}
+
+	if (ajax) {
+		output.forEach(function (item) {
+			if (typeof item.type == "function") {
+				item.type = "function";
+			}
+		});
+	}
+
+	output = output.concat(this.filtersToArray(this.filterList, ajax));
+
+	return output;
+};
+
+//filter to Object
+Filter.prototype.filtersToArray = function (filterList, ajax) {
+	var _this2 = this;
+
+	var output = [];
+
+	filterList.forEach(function (filter) {
+		var item;
+
+		if (Array.isArray(filter)) {
+			output.push(_this2.filtersToArray(filter, ajax));
+		} else {
+			item = { field: filter.field, type: filter.type, value: filter.value };
+
+			if (ajax) {
+				if (typeof item.type == "function") {
+					item.type = "function";
+				}
+			}
+
+			output.push(item);
+		}
+	});
+
+	return output;
+};
+
+//get all filters
+Filter.prototype.getHeaderFilters = function () {
+	var self = this,
+	    output = [];
+
+	for (var key in this.headerFilters) {
+		output.push({ field: key, type: this.headerFilters[key].type, value: this.headerFilters[key].value });
+	}
+
+	return output;
+};
+
+//remove filter from array
+Filter.prototype.removeFilter = function (field, type, value) {
+	var self = this;
+
+	if (!Array.isArray(field)) {
+		field = [{ field: field, type: type, value: value }];
+	}
+
+	field.forEach(function (filter) {
+		var index = -1;
+
+		if (_typeof(filter.field) == "object") {
+			index = self.filterList.findIndex(function (element) {
+				return filter === element;
+			});
+		} else {
+			index = self.filterList.findIndex(function (element) {
+				return filter.field === element.field && filter.type === element.type && filter.value === element.value;
+			});
+		}
+
+		if (index > -1) {
+			self.filterList.splice(index, 1);
+			self.changed = true;
+		} else {
+			console.warn("Filter Error - No matching filter type found, ignoring: ", filter.type);
+		}
+	});
+
+	if (this.table.options.persistence && this.table.modExists("persistence", true) && this.table.modules.persistence.config.filter) {
+		this.table.modules.persistence.save("filter");
+	}
+};
+
+//clear filters
+Filter.prototype.clearFilter = function (all) {
+	this.filterList = [];
+
+	if (all) {
+		this.clearHeaderFilter();
+	}
+
+	this.changed = true;
+
+	if (this.table.options.persistence && this.table.modExists("persistence", true) && this.table.modules.persistence.config.filter) {
+		this.table.modules.persistence.save("filter");
+	}
+};
+
+//clear header filters
+Filter.prototype.clearHeaderFilter = function () {
+	var self = this;
+
+	this.headerFilters = {};
+	self.prevHeaderFilterChangeCheck = "{}";
+
+	this.headerFilterColumns.forEach(function (column) {
+		if (typeof column.modules.filter.value !== "undefined") {
+			delete column.modules.filter.value;
+		}
+		column.modules.filter.prevSuccess = undefined;
+		self.reloadHeaderFilter(column);
+	});
+
+	this.changed = true;
+};
+
+//search data and return matching rows
+Filter.prototype.search = function (searchType, field, type, value) {
+	var self = this,
+	    activeRows = [],
+	    filterList = [];
+
+	if (!Array.isArray(field)) {
+		field = [{ field: field, type: type, value: value }];
+	}
+
+	field.forEach(function (filter) {
+		filter = self.findFilter(filter);
+
+		if (filter) {
+			filterList.push(filter);
+		}
+	});
+
+	this.table.rowManager.rows.forEach(function (row) {
+		var match = true;
+
+		filterList.forEach(function (filter) {
+			if (!self.filterRecurse(filter, row.getData())) {
+				match = false;
+			}
+		});
+
+		if (match) {
+			activeRows.push(searchType === "data" ? row.getData("data") : row.getComponent());
+		}
+	});
+
+	return activeRows;
+};
+
+//filter row array
+Filter.prototype.filter = function (rowList, filters) {
+	var self = this,
+	    activeRows = [],
+	    activeRowComponents = [];
+
+	if (self.table.options.dataFiltering) {
+		self.table.options.dataFiltering.call(self.table, self.getFilters());
+	}
+
+	if (!self.table.options.ajaxFiltering && (self.filterList.length || Object.keys(self.headerFilters).length)) {
+
+		rowList.forEach(function (row) {
+			if (self.filterRow(row)) {
+				activeRows.push(row);
+			}
+		});
+	} else {
+		activeRows = rowList.slice(0);
+	}
+
+	if (self.table.options.dataFiltered) {
+
+		activeRows.forEach(function (row) {
+			activeRowComponents.push(row.getComponent());
+		});
+
+		self.table.options.dataFiltered.call(self.table, self.getFilters(), activeRowComponents);
+	}
+
+	return activeRows;
+};
+
+//filter individual row
+Filter.prototype.filterRow = function (row, filters) {
+	var self = this,
+	    match = true,
+	    data = row.getData();
+
+	self.filterList.forEach(function (filter) {
+		if (!self.filterRecurse(filter, data)) {
+			match = false;
+		}
+	});
+
+	for (var field in self.headerFilters) {
+		if (!self.headerFilters[field].func(data)) {
+			match = false;
+		}
+	}
+
+	return match;
+};
+
+Filter.prototype.filterRecurse = function (filter, data) {
+	var self = this,
+	    match = false;
+
+	if (Array.isArray(filter)) {
+		filter.forEach(function (subFilter) {
+			if (self.filterRecurse(subFilter, data)) {
+				match = true;
+			}
+		});
+	} else {
+		match = filter.func(data);
+	}
+
+	return match;
+};
+
+//list of available filters
+Filter.prototype.filters = {
+
+	//equal to
+	"=": function _(filterVal, rowVal, rowData, filterParams) {
+		return rowVal == filterVal ? true : false;
+	},
+
+	//less than
+	"<": function _(filterVal, rowVal, rowData, filterParams) {
+		return rowVal < filterVal ? true : false;
+	},
+
+	//less than or equal to
+	"<=": function _(filterVal, rowVal, rowData, filterParams) {
+		return rowVal <= filterVal ? true : false;
+	},
+
+	//greater than
+	">": function _(filterVal, rowVal, rowData, filterParams) {
+		return rowVal > filterVal ? true : false;
+	},
+
+	//greater than or equal to
+	">=": function _(filterVal, rowVal, rowData, filterParams) {
+		return rowVal >= filterVal ? true : false;
+	},
+
+	//not equal to
+	"!=": function _(filterVal, rowVal, rowData, filterParams) {
+		return rowVal != filterVal ? true : false;
+	},
+
+	"regex": function regex(filterVal, rowVal, rowData, filterParams) {
+
+		if (typeof filterVal == "string") {
+			filterVal = new RegExp(filterVal);
+		}
+
+		return filterVal.test(rowVal);
+	},
+
+	//contains the string
+	"like": function like(filterVal, rowVal, rowData, filterParams) {
+		if (filterVal === null || typeof filterVal === "undefined") {
+			return rowVal === filterVal ? true : false;
+		} else {
+			if (typeof rowVal !== 'undefined' && rowVal !== null) {
+				return String(rowVal).toLowerCase().indexOf(filterVal.toLowerCase()) > -1;
+			} else {
+				return false;
+			}
+		}
+	},
+
+	//contains the keywords
+	"keywords": function keywords(filterVal, rowVal, rowData, filterParams) {
+		var keywords = filterVal.toLowerCase().split(typeof filterParams.separator === "undefined" ? " " : filterParams.separator),
+		    value = String(rowVal === null || typeof rowVal === "undefined" ? "" : rowVal).toLowerCase(),
+		    matches = [];
+
+		keywords.forEach(function (keyword) {
+			if (value.includes(keyword)) {
+				matches.push(true);
+			}
+		});
+
+		return filterParams.matchAll ? matches.length === keywords.length : !!matches.length;
+	},
+
+	//starts with the string
+	"starts": function starts(filterVal, rowVal, rowData, filterParams) {
+		if (filterVal === null || typeof filterVal === "undefined") {
+			return rowVal === filterVal ? true : false;
+		} else {
+			if (typeof rowVal !== 'undefined' && rowVal !== null) {
+				return String(rowVal).toLowerCase().startsWith(filterVal.toLowerCase());
+			} else {
+				return false;
+			}
+		}
+	},
+
+	//ends with the string
+	"ends": function ends(filterVal, rowVal, rowData, filterParams) {
+		if (filterVal === null || typeof filterVal === "undefined") {
+			return rowVal === filterVal ? true : false;
+		} else {
+			if (typeof rowVal !== 'undefined' && rowVal !== null) {
+				return String(rowVal).toLowerCase().endsWith(filterVal.toLowerCase());
+			} else {
+				return false;
+			}
+		}
+	},
+
+	//in array
+	"in": function _in(filterVal, rowVal, rowData, filterParams) {
+		if (Array.isArray(filterVal)) {
+			return filterVal.length ? filterVal.indexOf(rowVal) > -1 : true;
+		} else {
+			console.warn("Filter Error - filter value is not an array:", filterVal);
+			return false;
+		}
+	}
+};
+
+Tabulator.prototype.registerModule("filter", Filter);

public/assets/vendors/tabulator/js/modules/format.js

@@ -0,0 +1,743 @@
+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; };
+
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+
+var Format = function Format(table) {
+	this.table = table; //hold Tabulator object
+};
+
+//initialize column formatter
+Format.prototype.initializeColumn = function (column) {
+	column.modules.format = this.lookupFormatter(column, "");
+
+	if (typeof column.definition.formatterPrint !== "undefined") {
+		column.modules.format.print = this.lookupFormatter(column, "Print");
+	}
+
+	if (typeof column.definition.formatterClipboard !== "undefined") {
+		column.modules.format.clipboard = this.lookupFormatter(column, "Clipboard");
+	}
+
+	if (typeof column.definition.formatterHtmlOutput !== "undefined") {
+		column.modules.format.htmlOutput = this.lookupFormatter(column, "HtmlOutput");
+	}
+};
+
+Format.prototype.lookupFormatter = function (column, type) {
+	var config = { params: column.definition["formatter" + type + "Params"] || {} },
+	    formatter = column.definition["formatter" + type];
+
+	//set column formatter
+	switch (typeof formatter === "undefined" ? "undefined" : _typeof(formatter)) {
+		case "string":
+
+			if (formatter === "tick") {
+				formatter = "tickCross";
+
+				if (typeof config.params.crossElement == "undefined") {
+					config.params.crossElement = false;
+				}
+
+				console.warn("DEPRECATION WARNING - the tick formatter has been deprecated, please use the tickCross formatter with the crossElement param set to false");
+			}
+
+			if (this.formatters[formatter]) {
+				config.formatter = this.formatters[formatter];
+			} else {
+				console.warn("Formatter Error - No such formatter found: ", formatter);
+				config.formatter = this.formatters.plaintext;
+			}
+			break;
+
+		case "function":
+			config.formatter = formatter;
+			break;
+
+		default:
+			config.formatter = this.formatters.plaintext;
+			break;
+	}
+
+	return config;
+};
+
+Format.prototype.cellRendered = function (cell) {
+	if (cell.modules.format && cell.modules.format.renderedCallback && !cell.modules.format.rendered) {
+		cell.modules.format.renderedCallback();
+		cell.modules.format.rendered = true;
+	}
+};
+
+//return a formatted value for a cell
+Format.prototype.formatValue = function (cell) {
+	var component = cell.getComponent(),
+	    params = typeof cell.column.modules.format.params === "function" ? cell.column.modules.format.params(component) : cell.column.modules.format.params;
+
+	function onRendered(callback) {
+		if (!cell.modules.format) {
+			cell.modules.format = {};
+		}
+
+		cell.modules.format.renderedCallback = callback;
+		cell.modules.format.rendered = false;
+	}
+
+	return cell.column.modules.format.formatter.call(this, component, params, onRendered);
+};
+
+Format.prototype.formatExportValue = function (cell, type) {
+	var formatter = cell.column.modules.format[type],
+	    params;
+
+	if (formatter) {
+		var onRendered = function onRendered(callback) {
+			if (!cell.modules.format) {
+				cell.modules.format = {};
+			}
+
+			cell.modules.format.renderedCallback = callback;
+			cell.modules.format.rendered = false;
+		};
+
+		params = typeof formatter.params === "function" ? formatter.params(component) : formatter.params;
+
+		return formatter.formatter.call(this, cell.getComponent(), params, onRendered);
+	} else {
+		return this.formatValue(cell);
+	}
+};
+
+Format.prototype.sanitizeHTML = function (value) {
+	if (value) {
+		var entityMap = {
+			'&': '&',
+			'<': '&lt;',
+			'>': '&gt;',
+			'"': '&quot;',
+			"'": '&#39;',
+			'/': '&#x2F;',
+			'`': '&#x60;',
+			'=': '&#x3D;'
+		};
+
+		return String(value).replace(/[&<>"'`=\/]/g, function (s) {
+			return entityMap[s];
+		});
+	} else {
+		return value;
+	}
+};
+
+Format.prototype.emptyToSpace = function (value) {
+	return value === null || typeof value === "undefined" || value === "" ? "&nbsp;" : value;
+};
+
+//get formatter for cell
+Format.prototype.getFormatter = function (formatter) {
+	var formatter;
+
+	switch (typeof formatter === "undefined" ? "undefined" : _typeof(formatter)) {
+		case "string":
+			if (this.formatters[formatter]) {
+				formatter = this.formatters[formatter];
+			} else {
+				console.warn("Formatter Error - No such formatter found: ", formatter);
+				formatter = this.formatters.plaintext;
+			}
+			break;
+
+		case "function":
+			formatter = formatter;
+			break;
+
+		default:
+			formatter = this.formatters.plaintext;
+			break;
+	}
+
+	return formatter;
+};
+
+//default data formatters
+Format.prototype.formatters = {
+	//plain text value
+	plaintext: function plaintext(cell, formatterParams, onRendered) {
+		return this.emptyToSpace(this.sanitizeHTML(cell.getValue()));
+	},
+
+	//html text value
+	html: function html(cell, formatterParams, onRendered) {
+		return cell.getValue();
+	},
+
+	//multiline text area
+	textarea: function textarea(cell, formatterParams, onRendered) {
+		cell.getElement().style.whiteSpace = "pre-wrap";
+		return this.emptyToSpace(this.sanitizeHTML(cell.getValue()));
+	},
+
+	//currency formatting
+	money: function money(cell, formatterParams, onRendered) {
+		var floatVal = parseFloat(cell.getValue()),
+		    number,
+		    integer,
+		    decimal,
+		    rgx;
+
+		var decimalSym = formatterParams.decimal || ".";
+		var thousandSym = formatterParams.thousand || ",";
+		var symbol = formatterParams.symbol || "";
+		var after = !!formatterParams.symbolAfter;
+		var precision = typeof formatterParams.precision !== "undefined" ? formatterParams.precision : 2;
+
+		if (isNaN(floatVal)) {
+			return this.emptyToSpace(this.sanitizeHTML(cell.getValue()));
+		}
+
+		number = precision !== false ? floatVal.toFixed(precision) : floatVal;
+		number = String(number).split(".");
+
+		integer = number[0];
+		decimal = number.length > 1 ? decimalSym + number[1] : "";
+
+		rgx = /(\d+)(\d{3})/;
+
+		while (rgx.test(integer)) {
+			integer = integer.replace(rgx, "$1" + thousandSym + "$2");
+		}
+
+		return after ? integer + decimal + symbol : symbol + integer + decimal;
+	},
+
+	//clickable anchor tag
+	link: function link(cell, formatterParams, onRendered) {
+		var value = cell.getValue(),
+		    urlPrefix = formatterParams.urlPrefix || "",
+		    download = formatterParams.download,
+		    label = value,
+		    el = document.createElement("a"),
+		    data;
+
+		if (formatterParams.labelField) {
+			data = cell.getData();
+			label = data[formatterParams.labelField];
+		}
+
+		if (formatterParams.label) {
+			switch (_typeof(formatterParams.label)) {
+				case "string":
+					label = formatterParams.label;
+					break;
+
+				case "function":
+					label = formatterParams.label(cell);
+					break;
+			}
+		}
+
+		if (label) {
+			if (formatterParams.urlField) {
+				data = cell.getData();
+				value = data[formatterParams.urlField];
+			}
+
+			if (formatterParams.url) {
+				switch (_typeof(formatterParams.url)) {
+					case "string":
+						value = formatterParams.url;
+						break;
+
+					case "function":
+						value = formatterParams.url(cell);
+						break;
+				}
+			}
+
+			el.setAttribute("href", urlPrefix + value);
+
+			if (formatterParams.target) {
+				el.setAttribute("target", formatterParams.target);
+			}
+
+			if (formatterParams.download) {
+
+				if (typeof download == "function") {
+					download = download(cell);
+				} else {
+					download = download === true ? "" : download;
+				}
+
+				el.setAttribute("download", download);
+			}
+
+			el.innerHTML = this.emptyToSpace(this.sanitizeHTML(label));
+
+			return el;
+		} else {
+			return "&nbsp;";
+		}
+	},
+
+	//image element
+	image: function image(cell, formatterParams, onRendered) {
+		var el = document.createElement("img"),
+		    src = cell.getValue();
+
+		if (formatterParams.urlPrefix) {
+			src = formatterParams.urlPrefix + cell.getValue();
+		}
+
+		if (formatterParams.urlSuffix) {
+			src = src + formatterParams.urlSuffix;
+		}
+
+		el.setAttribute("src", src);
+
+		switch (_typeof(formatterParams.height)) {
+			case "number":
+				el.style.height = formatterParams.height + "px";
+				break;
+
+			case "string":
+				el.style.height = formatterParams.height;
+				break;
+		}
+
+		switch (_typeof(formatterParams.width)) {
+			case "number":
+				el.style.width = formatterParams.width + "px";
+				break;
+
+			case "string":
+				el.style.width = formatterParams.width;
+				break;
+		}
+
+		el.addEventListener("load", function () {
+			cell.getRow().normalizeHeight();
+		});
+
+		return el;
+	},
+
+	//tick or cross
+	tickCross: function tickCross(cell, formatterParams, onRendered) {
+		var value = cell.getValue(),
+		    element = cell.getElement(),
+		    empty = formatterParams.allowEmpty,
+		    truthy = formatterParams.allowTruthy,
+		    tick = typeof formatterParams.tickElement !== "undefined" ? formatterParams.tickElement : '<svg enable-background="new 0 0 24 24" height="14" width="14" viewBox="0 0 24 24" xml:space="preserve" ><path fill="#2DC214" clip-rule="evenodd" d="M21.652,3.211c-0.293-0.295-0.77-0.295-1.061,0L9.41,14.34  c-0.293,0.297-0.771,0.297-1.062,0L3.449,9.351C3.304,9.203,3.114,9.13,2.923,9.129C2.73,9.128,2.534,9.201,2.387,9.351  l-2.165,1.946C0.078,11.445,0,11.63,0,11.823c0,0.194,0.078,0.397,0.223,0.544l4.94,5.184c0.292,0.296,0.771,0.776,1.062,1.07  l2.124,2.141c0.292,0.293,0.769,0.293,1.062,0l14.366-14.34c0.293-0.294,0.293-0.777,0-1.071L21.652,3.211z" fill-rule="evenodd"/></svg>',
+		    cross = typeof formatterParams.crossElement !== "undefined" ? formatterParams.crossElement : '<svg enable-background="new 0 0 24 24" height="14" width="14"  viewBox="0 0 24 24" xml:space="preserve" ><path fill="#CE1515" d="M22.245,4.015c0.313,0.313,0.313,0.826,0,1.139l-6.276,6.27c-0.313,0.312-0.313,0.826,0,1.14l6.273,6.272  c0.313,0.313,0.313,0.826,0,1.14l-2.285,2.277c-0.314,0.312-0.828,0.312-1.142,0l-6.271-6.271c-0.313-0.313-0.828-0.313-1.141,0  l-6.276,6.267c-0.313,0.313-0.828,0.313-1.141,0l-2.282-2.28c-0.313-0.313-0.313-0.826,0-1.14l6.278-6.269  c0.313-0.312,0.313-0.826,0-1.14L1.709,5.147c-0.314-0.313-0.314-0.827,0-1.14l2.284-2.278C4.308,1.417,4.821,1.417,5.135,1.73  L11.405,8c0.314,0.314,0.828,0.314,1.141,0.001l6.276-6.267c0.312-0.312,0.826-0.312,1.141,0L22.245,4.015z"/></svg>';
+
+		if (truthy && value || value === true || value === "true" || value === "True" || value === 1 || value === "1") {
+			element.setAttribute("aria-checked", true);
+			return tick || "";
+		} else {
+			if (empty && (value === "null" || value === "" || value === null || typeof value === "undefined")) {
+				element.setAttribute("aria-checked", "mixed");
+				return "";
+			} else {
+				element.setAttribute("aria-checked", false);
+				return cross || "";
+			}
+		}
+	},
+
+	datetime: function datetime(cell, formatterParams, onRendered) {
+		var inputFormat = formatterParams.inputFormat || "YYYY-MM-DD hh:mm:ss";
+		var outputFormat = formatterParams.outputFormat || "DD/MM/YYYY hh:mm:ss";
+		var invalid = typeof formatterParams.invalidPlaceholder !== "undefined" ? formatterParams.invalidPlaceholder : "";
+		var value = cell.getValue();
+
+		var newDatetime = moment(value, inputFormat);
+
+		if (newDatetime.isValid()) {
+			return formatterParams.timezone ? newDatetime.tz(formatterParams.timezone).format(outputFormat) : newDatetime.format(outputFormat);
+		} else {
+
+			if (invalid === true) {
+				return value;
+			} else if (typeof invalid === "function") {
+				return invalid(value);
+			} else {
+				return invalid;
+			}
+		}
+	},
+
+	datetimediff: function datetime(cell, formatterParams, onRendered) {
+		var inputFormat = formatterParams.inputFormat || "YYYY-MM-DD hh:mm:ss";
+		var invalid = typeof formatterParams.invalidPlaceholder !== "undefined" ? formatterParams.invalidPlaceholder : "";
+		var suffix = typeof formatterParams.suffix !== "undefined" ? formatterParams.suffix : false;
+		var unit = typeof formatterParams.unit !== "undefined" ? formatterParams.unit : undefined;
+		var humanize = typeof formatterParams.humanize !== "undefined" ? formatterParams.humanize : false;
+		var date = typeof formatterParams.date !== "undefined" ? formatterParams.date : moment();
+		var value = cell.getValue();
+
+		var newDatetime = moment(value, inputFormat);
+
+		if (newDatetime.isValid()) {
+			if (humanize) {
+				return moment.duration(newDatetime.diff(date)).humanize(suffix);
+			} else {
+				return newDatetime.diff(date, unit) + (suffix ? " " + suffix : "");
+			}
+		} else {
+
+			if (invalid === true) {
+				return value;
+			} else if (typeof invalid === "function") {
+				return invalid(value);
+			} else {
+				return invalid;
+			}
+		}
+	},
+
+	//select
+	lookup: function lookup(cell, formatterParams, onRendered) {
+		var value = cell.getValue();
+
+		if (typeof formatterParams[value] === "undefined") {
+			console.warn('Missing display value for ' + value);
+			return value;
+		}
+
+		return formatterParams[value];
+	},
+
+	//star rating
+	star: function star(cell, formatterParams, onRendered) {
+		var value = cell.getValue(),
+		    element = cell.getElement(),
+		    maxStars = formatterParams && formatterParams.stars ? formatterParams.stars : 5,
+		    stars = document.createElement("span"),
+		    star = document.createElementNS('http://www.w3.org/2000/svg', "svg"),
+		    starActive = '<polygon fill="#FFEA00" stroke="#C1AB60" stroke-width="37.6152" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" points="259.216,29.942 330.27,173.919 489.16,197.007 374.185,309.08 401.33,467.31 259.216,392.612 117.104,467.31 144.25,309.08 29.274,197.007 188.165,173.919 "/>',
+		    starInactive = '<polygon fill="#D2D2D2" stroke="#686868" stroke-width="37.6152" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" points="259.216,29.942 330.27,173.919 489.16,197.007 374.185,309.08 401.33,467.31 259.216,392.612 117.104,467.31 144.25,309.08 29.274,197.007 188.165,173.919 "/>';
+
+		//style stars holder
+		stars.style.verticalAlign = "middle";
+
+		//style star
+		star.setAttribute("width", "14");
+		star.setAttribute("height", "14");
+		star.setAttribute("viewBox", "0 0 512 512");
+		star.setAttribute("xml:space", "preserve");
+		star.style.padding = "0 1px";
+
+		value = value && !isNaN(value) ? parseInt(value) : 0;
+
+		value = Math.max(0, Math.min(value, maxStars));
+
+		for (var i = 1; i <= maxStars; i++) {
+			var nextStar = star.cloneNode(true);
+			nextStar.innerHTML = i <= value ? starActive : starInactive;
+
+			stars.appendChild(nextStar);
+		}
+
+		element.style.whiteSpace = "nowrap";
+		element.style.overflow = "hidden";
+		element.style.textOverflow = "ellipsis";
+
+		element.setAttribute("aria-label", value);
+
+		return stars;
+	},
+
+	traffic: function traffic(cell, formatterParams, onRendered) {
+		var value = this.sanitizeHTML(cell.getValue()) || 0,
+		    el = document.createElement("span"),
+		    max = formatterParams && formatterParams.max ? formatterParams.max : 100,
+		    min = formatterParams && formatterParams.min ? formatterParams.min : 0,
+		    colors = formatterParams && typeof formatterParams.color !== "undefined" ? formatterParams.color : ["red", "orange", "green"],
+		    color = "#666666",
+		    percent,
+		    percentValue;
+
+		if (isNaN(value) || typeof cell.getValue() === "undefined") {
+			return;
+		}
+
+		el.classList.add("tabulator-traffic-light");
+
+		//make sure value is in range
+		percentValue = parseFloat(value) <= max ? parseFloat(value) : max;
+		percentValue = parseFloat(percentValue) >= min ? parseFloat(percentValue) : min;
+
+		//workout percentage
+		percent = (max - min) / 100;
+		percentValue = Math.round((percentValue - min) / percent);
+
+		//set color
+		switch (typeof colors === "undefined" ? "undefined" : _typeof(colors)) {
+			case "string":
+				color = colors;
+				break;
+			case "function":
+				color = colors(value);
+				break;
+			case "object":
+				if (Array.isArray(colors)) {
+					var unit = 100 / colors.length;
+					var index = Math.floor(percentValue / unit);
+
+					index = Math.min(index, colors.length - 1);
+					index = Math.max(index, 0);
+					color = colors[index];
+					break;
+				}
+		}
+
+		el.style.backgroundColor = color;
+
+		return el;
+	},
+
+	//progress bar
+	progress: function progress(cell, formatterParams, onRendered) {
+		//progress bar
+		var value = this.sanitizeHTML(cell.getValue()) || 0,
+		    element = cell.getElement(),
+		    max = formatterParams && formatterParams.max ? formatterParams.max : 100,
+		    min = formatterParams && formatterParams.min ? formatterParams.min : 0,
+		    legendAlign = formatterParams && formatterParams.legendAlign ? formatterParams.legendAlign : "center",
+		    percent,
+		    percentValue,
+		    color,
+		    legend,
+		    legendColor,
+		    top,
+		    left,
+		    right,
+		    bottom;
+
+		//make sure value is in range
+		percentValue = parseFloat(value) <= max ? parseFloat(value) : max;
+		percentValue = parseFloat(percentValue) >= min ? parseFloat(percentValue) : min;
+
+		//workout percentage
+		percent = (max - min) / 100;
+		percentValue = Math.round((percentValue - min) / percent);
+
+		//set bar color
+		switch (_typeof(formatterParams.color)) {
+			case "string":
+				color = formatterParams.color;
+				break;
+			case "function":
+				color = formatterParams.color(value);
+				break;
+			case "object":
+				if (Array.isArray(formatterParams.color)) {
+					var unit = 100 / formatterParams.color.length;
+					var index = Math.floor(percentValue / unit);
+
+					index = Math.min(index, formatterParams.color.length - 1);
+					index = Math.max(index, 0);
+					color = formatterParams.color[index];
+					break;
+				}
+			default:
+				color = "#2DC214";
+		}
+
+		//generate legend
+		switch (_typeof(formatterParams.legend)) {
+			case "string":
+				legend = formatterParams.legend;
+				break;
+			case "function":
+				legend = formatterParams.legend(value);
+				break;
+			case "boolean":
+				legend = value;
+				break;
+			default:
+				legend = false;
+		}
+
+		//set legend color
+		switch (_typeof(formatterParams.legendColor)) {
+			case "string":
+				legendColor = formatterParams.legendColor;
+				break;
+			case "function":
+				legendColor = formatterParams.legendColor(value);
+				break;
+			case "object":
+				if (Array.isArray(formatterParams.legendColor)) {
+					var unit = 100 / formatterParams.legendColor.length;
+					var index = Math.floor(percentValue / unit);
+
+					index = Math.min(index, formatterParams.legendColor.length - 1);
+					index = Math.max(index, 0);
+					legendColor = formatterParams.legendColor[index];
+				}
+				break;
+			default:
+				legendColor = "#000";
+		}
+
+		element.style.minWidth = "30px";
+		element.style.position = "relative";
+
+		element.setAttribute("aria-label", percentValue);
+
+		var barEl = document.createElement("div");
+		barEl.style.display = "inline-block";
+		barEl.style.position = "relative";
+		barEl.style.width = percentValue + "%";
+		barEl.style.backgroundColor = color;
+		barEl.style.height = "100%";
+
+		barEl.setAttribute('data-max', max);
+		barEl.setAttribute('data-min', min);
+
+		if (legend) {
+			var legendEl = document.createElement("div");
+			legendEl.style.position = "absolute";
+			legendEl.style.top = "4px";
+			legendEl.style.left = 0;
+			legendEl.style.textAlign = legendAlign;
+			legendEl.style.width = "100%";
+			legendEl.style.color = legendColor;
+			legendEl.innerHTML = legend;
+		}
+
+		onRendered(function () {
+
+			//handle custom element needed if formatter is to be included in printed/downloaded output
+			if (!(cell instanceof CellComponent)) {
+				var holderEl = document.createElement("div");
+				holderEl.style.position = "absolute";
+				holderEl.style.top = "4px";
+				holderEl.style.bottom = "4px";
+				holderEl.style.left = "4px";
+				holderEl.style.right = "4px";
+
+				element.appendChild(holderEl);
+
+				element = holderEl;
+			}
+
+			element.appendChild(barEl);
+
+			if (legend) {
+				element.appendChild(legendEl);
+			}
+		});
+
+		return "";
+	},
+
+	//background color
+	color: function color(cell, formatterParams, onRendered) {
+		cell.getElement().style.backgroundColor = this.sanitizeHTML(cell.getValue());
+		return "";
+	},
+
+	//tick icon
+	buttonTick: function buttonTick(cell, formatterParams, onRendered) {
+		return '<svg enable-background="new 0 0 24 24" height="14" width="14" viewBox="0 0 24 24" xml:space="preserve" ><path fill="#2DC214" clip-rule="evenodd" d="M21.652,3.211c-0.293-0.295-0.77-0.295-1.061,0L9.41,14.34  c-0.293,0.297-0.771,0.297-1.062,0L3.449,9.351C3.304,9.203,3.114,9.13,2.923,9.129C2.73,9.128,2.534,9.201,2.387,9.351  l-2.165,1.946C0.078,11.445,0,11.63,0,11.823c0,0.194,0.078,0.397,0.223,0.544l4.94,5.184c0.292,0.296,0.771,0.776,1.062,1.07  l2.124,2.141c0.292,0.293,0.769,0.293,1.062,0l14.366-14.34c0.293-0.294,0.293-0.777,0-1.071L21.652,3.211z" fill-rule="evenodd"/></svg>';
+	},
+
+	//cross icon
+	buttonCross: function buttonCross(cell, formatterParams, onRendered) {
+		return '<svg enable-background="new 0 0 24 24" height="14" width="14" viewBox="0 0 24 24" xml:space="preserve" ><path fill="#CE1515" d="M22.245,4.015c0.313,0.313,0.313,0.826,0,1.139l-6.276,6.27c-0.313,0.312-0.313,0.826,0,1.14l6.273,6.272  c0.313,0.313,0.313,0.826,0,1.14l-2.285,2.277c-0.314,0.312-0.828,0.312-1.142,0l-6.271-6.271c-0.313-0.313-0.828-0.313-1.141,0  l-6.276,6.267c-0.313,0.313-0.828,0.313-1.141,0l-2.282-2.28c-0.313-0.313-0.313-0.826,0-1.14l6.278-6.269  c0.313-0.312,0.313-0.826,0-1.14L1.709,5.147c-0.314-0.313-0.314-0.827,0-1.14l2.284-2.278C4.308,1.417,4.821,1.417,5.135,1.73  L11.405,8c0.314,0.314,0.828,0.314,1.141,0.001l6.276-6.267c0.312-0.312,0.826-0.312,1.141,0L22.245,4.015z"/></svg>';
+	},
+
+	//current row number
+	rownum: function rownum(cell, formatterParams, onRendered) {
+		return this.table.rowManager.activeRows.indexOf(cell.getRow()._getSelf()) + 1;
+	},
+
+	//row handle
+	handle: function handle(cell, formatterParams, onRendered) {
+		cell.getElement().classList.add("tabulator-row-handle");
+		return "<div class='tabulator-row-handle-box'><div class='tabulator-row-handle-bar'></div><div class='tabulator-row-handle-bar'></div><div class='tabulator-row-handle-bar'></div></div>";
+	},
+
+	responsiveCollapse: function responsiveCollapse(cell, formatterParams, onRendered) {
+		var self = this,
+		    open = false,
+		    el = document.createElement("div"),
+		    config = cell.getRow()._row.modules.responsiveLayout;
+
+		el.classList.add("tabulator-responsive-collapse-toggle");
+		el.innerHTML = "<span class='tabulator-responsive-collapse-toggle-open'>+</span><span class='tabulator-responsive-collapse-toggle-close'>-</span>";
+
+		cell.getElement().classList.add("tabulator-row-handle");
+
+		function toggleList(isOpen) {
+			var collapseEl = config.element;
+
+			config.open = isOpen;
+
+			if (collapseEl) {
+
+				if (config.open) {
+					el.classList.add("open");
+					collapseEl.style.display = '';
+				} else {
+					el.classList.remove("open");
+					collapseEl.style.display = 'none';
+				}
+			}
+		}
+
+		el.addEventListener("click", function (e) {
+			e.stopImmediatePropagation();
+			toggleList(!config.open);
+		});
+
+		toggleList(config.open);
+
+		return el;
+	},
+
+	rowSelection: function rowSelection(cell, formatterParams, onRendered) {
+		var _this = this;
+
+		var checkbox = document.createElement("input");
+
+		checkbox.type = 'checkbox';
+
+		if (this.table.modExists("selectRow", true)) {
+
+			checkbox.addEventListener("click", function (e) {
+				e.stopPropagation();
+			});
+
+			if (typeof cell.getRow == 'function') {
+				var row = cell.getRow();
+
+				if (row instanceof RowComponent) {
+
+					checkbox.addEventListener("change", function (e) {
+						row.toggleSelect();
+					});
+
+					checkbox.checked = row.isSelected && row.isSelected();
+					this.table.modules.selectRow.registerRowSelectCheckbox(row, checkbox);
+				} else {
+					checkbox = "";
+				}
+			} else {
+				checkbox.addEventListener("change", function (e) {
+					if (_this.table.modules.selectRow.selectedRows.length) {
+						_this.table.deselectRow();
+					} else {
+						_this.table.selectRow(formatterParams.rowRange);
+					}
+				});
+
+				this.table.modules.selectRow.registerHeaderSelectCheckbox(checkbox);
+			}
+		}
+		return checkbox;
+	}
+};
+
+Tabulator.prototype.registerModule("format", Format);

public/assets/vendors/tabulator/js/modules/frozen_columns.js

@@ -0,0 +1,275 @@
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+
+var FrozenColumns = function FrozenColumns(table) {
+	this.table = table; //hold Tabulator object
+	this.leftColumns = [];
+	this.rightColumns = [];
+	this.leftMargin = 0;
+	this.rightMargin = 0;
+	this.rightPadding = 0;
+	this.initializationMode = "left";
+	this.active = false;
+	this.scrollEndTimer = false;
+};
+
+//reset initial state
+FrozenColumns.prototype.reset = function () {
+	this.initializationMode = "left";
+	this.leftColumns = [];
+	this.rightColumns = [];
+	this.leftMargin = 0;
+	this.rightMargin = 0;
+	this.rightMargin = 0;
+	this.active = false;
+
+	this.table.columnManager.headersElement.style.marginLeft = 0;
+	this.table.columnManager.element.style.paddingRight = 0;
+};
+
+//initialize specific column
+FrozenColumns.prototype.initializeColumn = function (column) {
+	var config = { margin: 0, edge: false };
+
+	if (!column.isGroup) {
+
+		if (this.frozenCheck(column)) {
+
+			config.position = this.initializationMode;
+
+			if (this.initializationMode == "left") {
+				this.leftColumns.push(column);
+			} else {
+				this.rightColumns.unshift(column);
+			}
+
+			this.active = true;
+
+			column.modules.frozen = config;
+		} else {
+			this.initializationMode = "right";
+		}
+	}
+};
+
+FrozenColumns.prototype.frozenCheck = function (column) {
+	var frozen = false;
+
+	if (column.parent.isGroup && column.definition.frozen) {
+		console.warn("Frozen Column Error - Parent column group must be frozen, not individual columns or sub column groups");
+	}
+
+	if (column.parent.isGroup) {
+		return this.frozenCheck(column.parent);
+	} else {
+		return column.definition.frozen;
+	}
+
+	return frozen;
+};
+
+//quick layout to smooth horizontal scrolling
+FrozenColumns.prototype.scrollHorizontal = function () {
+	var _this = this;
+
+	var rows;
+
+	if (this.active) {
+		clearTimeout(this.scrollEndTimer);
+
+		//layout all rows after scroll is complete
+		this.scrollEndTimer = setTimeout(function () {
+			_this.layout();
+		}, 100);
+
+		rows = this.table.rowManager.getVisibleRows();
+
+		this.calcMargins();
+
+		this.layoutColumnPosition();
+
+		this.layoutCalcRows();
+
+		rows.forEach(function (row) {
+			if (row.type === "row") {
+				_this.layoutRow(row);
+			}
+		});
+
+		this.table.rowManager.tableElement.style.marginRight = this.rightMargin;
+	}
+};
+
+//calculate margins for rows
+FrozenColumns.prototype.calcMargins = function () {
+	this.leftMargin = this._calcSpace(this.leftColumns, this.leftColumns.length) + "px";
+	this.table.columnManager.headersElement.style.marginLeft = this.leftMargin;
+
+	this.rightMargin = this._calcSpace(this.rightColumns, this.rightColumns.length) + "px";
+	this.table.columnManager.element.style.paddingRight = this.rightMargin;
+
+	//calculate right frozen columns
+	this.rightPadding = this.table.rowManager.element.clientWidth + this.table.columnManager.scrollLeft;
+};
+
+//layout calculation rows
+FrozenColumns.prototype.layoutCalcRows = function () {
+	if (this.table.modExists("columnCalcs")) {
+		if (this.table.modules.columnCalcs.topInitialized && this.table.modules.columnCalcs.topRow) {
+			this.layoutRow(this.table.modules.columnCalcs.topRow);
+		}
+		if (this.table.modules.columnCalcs.botInitialized && this.table.modules.columnCalcs.botRow) {
+			this.layoutRow(this.table.modules.columnCalcs.botRow);
+		}
+	}
+};
+
+//calculate column positions and layout headers
+FrozenColumns.prototype.layoutColumnPosition = function (allCells) {
+	var _this2 = this;
+
+	var leftParents = [];
+
+	this.leftColumns.forEach(function (column, i) {
+		column.modules.frozen.margin = _this2._calcSpace(_this2.leftColumns, i) + _this2.table.columnManager.scrollLeft + "px";
+
+		if (i == _this2.leftColumns.length - 1) {
+			column.modules.frozen.edge = true;
+		} else {
+			column.modules.frozen.edge = false;
+		}
+
+		if (column.parent.isGroup) {
+			var parentEl = _this2.getColGroupParentElement(column);
+			if (!leftParents.includes(parentEl)) {
+				_this2.layoutElement(parentEl, column);
+				leftParents.push(parentEl);
+			}
+
+			if (column.modules.frozen.edge) {
+				parentEl.classList.add("tabulator-frozen-" + column.modules.frozen.position);
+			}
+		} else {
+			_this2.layoutElement(column.getElement(), column);
+		}
+
+		if (allCells) {
+			column.cells.forEach(function (cell) {
+				_this2.layoutElement(cell.getElement(true), column);
+			});
+		}
+	});
+
+	this.rightColumns.forEach(function (column, i) {
+		column.modules.frozen.margin = _this2.rightPadding - _this2._calcSpace(_this2.rightColumns, i + 1) + "px";
+
+		if (i == _this2.rightColumns.length - 1) {
+			column.modules.frozen.edge = true;
+		} else {
+			column.modules.frozen.edge = false;
+		}
+
+		if (column.parent.isGroup) {
+			_this2.layoutElement(_this2.getColGroupParentElement(column), column);
+		} else {
+			_this2.layoutElement(column.getElement(), column);
+		}
+
+		if (allCells) {
+			column.cells.forEach(function (cell) {
+				_this2.layoutElement(cell.getElement(true), column);
+			});
+		}
+	});
+};
+
+FrozenColumns.prototype.getColGroupParentElement = function (column) {
+	return column.parent.isGroup ? this.getColGroupParentElement(column.parent) : column.getElement();
+};
+
+//layout columns appropropriatly
+FrozenColumns.prototype.layout = function () {
+	var self = this,
+	    rightMargin = 0;
+
+	if (self.active) {
+
+		//calculate row padding
+		this.calcMargins();
+
+		// self.table.rowManager.activeRows.forEach(function(row){
+		// 	self.layoutRow(row);
+		// });
+
+		// if(self.table.options.dataTree){
+		self.table.rowManager.getDisplayRows().forEach(function (row) {
+			if (row.type === "row") {
+				self.layoutRow(row);
+			}
+		});
+		// }
+
+		this.layoutCalcRows();
+
+		//calculate left columns
+		this.layoutColumnPosition(true);
+
+		// if(tableHolder.scrollHeight > tableHolder.clientHeight){
+		// 	rightMargin -= tableHolder.offsetWidth - tableHolder.clientWidth;
+		// }
+
+		this.table.rowManager.tableElement.style.marginRight = this.rightMargin;
+	}
+};
+
+FrozenColumns.prototype.layoutRow = function (row) {
+	var _this3 = this;
+
+	var rowEl = row.getElement();
+
+	rowEl.style.paddingLeft = this.leftMargin;
+	// rowEl.style.paddingRight = this.rightMargin + "px";
+
+	this.leftColumns.forEach(function (column) {
+		var cell = row.getCell(column);
+
+		if (cell) {
+			_this3.layoutElement(cell.getElement(true), column);
+		}
+	});
+
+	this.rightColumns.forEach(function (column) {
+		var cell = row.getCell(column);
+
+		if (cell) {
+			_this3.layoutElement(cell.getElement(true), column);
+		}
+	});
+};
+
+FrozenColumns.prototype.layoutElement = function (element, column) {
+
+	if (column.modules.frozen) {
+		element.style.position = "absolute";
+		element.style.left = column.modules.frozen.margin;
+
+		element.classList.add("tabulator-frozen");
+
+		if (column.modules.frozen.edge) {
+			element.classList.add("tabulator-frozen-" + column.modules.frozen.position);
+		}
+	}
+};
+
+FrozenColumns.prototype._calcSpace = function (columns, index) {
+	var width = 0;
+
+	for (var i = 0; i < index; i++) {
+		if (columns[i].visible) {
+			width += columns[i].getWidth();
+		}
+	}
+
+	return width;
+};
+
+Tabulator.prototype.registerModule("frozenColumns", FrozenColumns);

public/assets/vendors/tabulator/js/modules/frozen_columns.min.js

@@ -0,0 +1,2 @@
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+var FrozenColumns=function(t){this.table=t,this.leftColumns=[],this.rightColumns=[],this.leftMargin=0,this.rightMargin=0,this.rightPadding=0,this.initializationMode="left",this.active=!1,this.scrollEndTimer=!1};FrozenColumns.prototype.reset=function(){this.initializationMode="left",this.leftColumns=[],this.rightColumns=[],this.leftMargin=0,this.rightMargin=0,this.rightMargin=0,this.active=!1,this.table.columnManager.headersElement.style.marginLeft=0,this.table.columnManager.element.style.paddingRight=0},FrozenColumns.prototype.initializeColumn=function(t){var e={margin:0,edge:!1};t.isGroup||(this.frozenCheck(t)?(e.position=this.initializationMode,"left"==this.initializationMode?this.leftColumns.push(t):this.rightColumns.unshift(t),this.active=!0,t.modules.frozen=e):this.initializationMode="right")},FrozenColumns.prototype.frozenCheck=function(t){return t.parent.isGroup&&t.definition.frozen&&console.warn("Frozen Column Error - Parent column group must be frozen, not individual columns or sub column groups"),t.parent.isGroup?this.frozenCheck(t.parent):t.definition.frozen},FrozenColumns.prototype.scrollHorizontal=function(){var t,e=this;this.active&&(clearTimeout(this.scrollEndTimer),this.scrollEndTimer=setTimeout(function(){e.layout()},100),t=this.table.rowManager.getVisibleRows(),this.calcMargins(),this.layoutColumnPosition(),this.layoutCalcRows(),t.forEach(function(t){"row"===t.type&&e.layoutRow(t)}),this.table.rowManager.tableElement.style.marginRight=this.rightMargin)},FrozenColumns.prototype.calcMargins=function(){this.leftMargin=this._calcSpace(this.leftColumns,this.leftColumns.length)+"px",this.table.columnManager.headersElement.style.marginLeft=this.leftMargin,this.rightMargin=this._calcSpace(this.rightColumns,this.rightColumns.length)+"px",this.table.columnManager.element.style.paddingRight=this.rightMargin,this.rightPadding=this.table.rowManager.element.clientWidth+this.table.columnManager.scrollLeft},FrozenColumns.prototype.layoutCalcRows=function(){this.table.modExists("columnCalcs")&&(this.table.modules.columnCalcs.topInitialized&&this.table.modules.columnCalcs.topRow&&this.layoutRow(this.table.modules.columnCalcs.topRow),this.table.modules.columnCalcs.botInitialized&&this.table.modules.columnCalcs.botRow&&this.layoutRow(this.table.modules.columnCalcs.botRow))},FrozenColumns.prototype.layoutColumnPosition=function(t){var e=this,o=[];this.leftColumns.forEach(function(n,l){if(n.modules.frozen.margin=e._calcSpace(e.leftColumns,l)+e.table.columnManager.scrollLeft+"px",l==e.leftColumns.length-1?n.modules.frozen.edge=!0:n.modules.frozen.edge=!1,n.parent.isGroup){var i=e.getColGroupParentElement(n);o.includes(i)||(e.layoutElement(i,n),o.push(i)),n.modules.frozen.edge&&i.classList.add("tabulator-frozen-"+n.modules.frozen.position)}else e.layoutElement(n.getElement(),n);t&&n.cells.forEach(function(t){e.layoutElement(t.getElement(!0),n)})}),this.rightColumns.forEach(function(o,n){o.modules.frozen.margin=e.rightPadding-e._calcSpace(e.rightColumns,n+1)+"px",n==e.rightColumns.length-1?o.modules.frozen.edge=!0:o.modules.frozen.edge=!1,o.parent.isGroup?e.layoutElement(e.getColGroupParentElement(o),o):e.layoutElement(o.getElement(),o),t&&o.cells.forEach(function(t){e.layoutElement(t.getElement(!0),o)})})},FrozenColumns.prototype.getColGroupParentElement=function(t){return t.parent.isGroup?this.getColGroupParentElement(t.parent):t.getElement()},FrozenColumns.prototype.layout=function(){var t=this;t.active&&(this.calcMargins(),t.table.rowManager.getDisplayRows().forEach(function(e){"row"===e.type&&t.layoutRow(e)}),this.layoutCalcRows(),this.layoutColumnPosition(!0),this.table.rowManager.tableElement.style.marginRight=this.rightMargin)},FrozenColumns.prototype.layoutRow=function(t){var e=this;t.getElement().style.paddingLeft=this.leftMargin,this.leftColumns.forEach(function(o){var n=t.getCell(o);n&&e.layoutElement(n.getElement(!0),o)}),this.rightColumns.forEach(function(o){var n=t.getCell(o);n&&e.layoutElement(n.getElement(!0),o)})},FrozenColumns.prototype.layoutElement=function(t,e){e.modules.frozen&&(t.style.position="absolute",t.style.left=e.modules.frozen.margin,t.classList.add("tabulator-frozen"),e.modules.frozen.edge&&t.classList.add("tabulator-frozen-"+e.modules.frozen.position))},FrozenColumns.prototype._calcSpace=function(t,e){for(var o=0,n=0;n<e;n++)t[n].visible&&(o+=t[n].getWidth());return o},Tabulator.prototype.registerModule("frozenColumns",FrozenColumns);

public/assets/vendors/tabulator/js/modules/frozen_rows.js

@@ -0,0 +1,106 @@
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+
+var FrozenRows = function FrozenRows(table) {
+	this.table = table; //hold Tabulator object
+	this.topElement = document.createElement("div");
+	this.rows = [];
+	this.displayIndex = 0; //index in display pipeline
+};
+
+FrozenRows.prototype.initialize = function () {
+	this.rows = [];
+
+	this.topElement.classList.add("tabulator-frozen-rows-holder");
+
+	// this.table.columnManager.element.append(this.topElement);
+	this.table.columnManager.getElement().insertBefore(this.topElement, this.table.columnManager.headersElement.nextSibling);
+};
+
+FrozenRows.prototype.setDisplayIndex = function (index) {
+	this.displayIndex = index;
+};
+
+FrozenRows.prototype.getDisplayIndex = function () {
+	return this.displayIndex;
+};
+
+FrozenRows.prototype.isFrozen = function () {
+	return !!this.rows.length;
+};
+
+//filter frozen rows out of display data
+FrozenRows.prototype.getRows = function (rows) {
+	var self = this,
+	    frozen = [],
+	    output = rows.slice(0);
+
+	this.rows.forEach(function (row) {
+		var index = output.indexOf(row);
+
+		if (index > -1) {
+			output.splice(index, 1);
+		}
+	});
+
+	return output;
+};
+
+FrozenRows.prototype.freezeRow = function (row) {
+	if (!row.modules.frozen) {
+		row.modules.frozen = true;
+		this.topElement.appendChild(row.getElement());
+		row.initialize();
+		row.normalizeHeight();
+		this.table.rowManager.adjustTableSize();
+
+		this.rows.push(row);
+
+		this.table.rowManager.refreshActiveData("display");
+
+		this.styleRows();
+	} else {
+		console.warn("Freeze Error - Row is already frozen");
+	}
+};
+
+FrozenRows.prototype.unfreezeRow = function (row) {
+	var index = this.rows.indexOf(row);
+
+	if (row.modules.frozen) {
+
+		row.modules.frozen = false;
+
+		this.detachRow(row);
+
+		this.table.rowManager.adjustTableSize();
+
+		this.table.rowManager.refreshActiveData("display");
+
+		if (this.rows.length) {
+			this.styleRows();
+		}
+	} else {
+		console.warn("Freeze Error - Row is already unfrozen");
+	}
+};
+
+FrozenRows.prototype.detachRow = function (row) {
+	var index = this.rows.indexOf(row);
+
+	if (index > -1) {
+		var rowEl = row.getElement();
+		rowEl.parentNode.removeChild(rowEl);
+
+		this.rows.splice(index, 1);
+	}
+};
+
+FrozenRows.prototype.styleRows = function (row) {
+	var self = this;
+
+	this.rows.forEach(function (row, i) {
+		self.table.rowManager.styleRow(row, i);
+	});
+};
+
+Tabulator.prototype.registerModule("frozenRows", FrozenRows);

public/assets/vendors/tabulator/js/modules/frozen_rows.min.js

@@ -0,0 +1,2 @@
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+var FrozenRows=function(e){this.table=e,this.topElement=document.createElement("div"),this.rows=[],this.displayIndex=0};FrozenRows.prototype.initialize=function(){this.rows=[],this.topElement.classList.add("tabulator-frozen-rows-holder"),this.table.columnManager.getElement().insertBefore(this.topElement,this.table.columnManager.headersElement.nextSibling)},FrozenRows.prototype.setDisplayIndex=function(e){this.displayIndex=e},FrozenRows.prototype.getDisplayIndex=function(){return this.displayIndex},FrozenRows.prototype.isFrozen=function(){return!!this.rows.length},FrozenRows.prototype.getRows=function(e){var o=e.slice(0);return this.rows.forEach(function(e){var t=o.indexOf(e);t>-1&&o.splice(t,1)}),o},FrozenRows.prototype.freezeRow=function(e){e.modules.frozen?console.warn("Freeze Error - Row is already frozen"):(e.modules.frozen=!0,this.topElement.appendChild(e.getElement()),e.initialize(),e.normalizeHeight(),this.table.rowManager.adjustTableSize(),this.rows.push(e),this.table.rowManager.refreshActiveData("display"),this.styleRows())},FrozenRows.prototype.unfreezeRow=function(e){this.rows.indexOf(e);e.modules.frozen?(e.modules.frozen=!1,this.detachRow(e),this.table.rowManager.adjustTableSize(),this.table.rowManager.refreshActiveData("display"),this.rows.length&&this.styleRows()):console.warn("Freeze Error - Row is already unfrozen")},FrozenRows.prototype.detachRow=function(e){var o=this.rows.indexOf(e);if(o>-1){var t=e.getElement();t.parentNode.removeChild(t),this.rows.splice(o,1)}},FrozenRows.prototype.styleRows=function(e){var o=this;this.rows.forEach(function(e,t){o.table.rowManager.styleRow(e,t)})},Tabulator.prototype.registerModule("frozenRows",FrozenRows);

public/assets/vendors/tabulator/js/modules/history.js

@@ -0,0 +1,156 @@
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+
+var History = function History(table) {
+	this.table = table; //hold Tabulator object
+
+	this.history = [];
+	this.index = -1;
+};
+
+History.prototype.clear = function () {
+	this.history = [];
+	this.index = -1;
+};
+
+History.prototype.action = function (type, component, data) {
+
+	this.history = this.history.slice(0, this.index + 1);
+
+	this.history.push({
+		type: type,
+		component: component,
+		data: data
+	});
+
+	this.index++;
+};
+
+History.prototype.getHistoryUndoSize = function () {
+	return this.index + 1;
+};
+
+History.prototype.getHistoryRedoSize = function () {
+	return this.history.length - (this.index + 1);
+};
+
+History.prototype.clearComponentHistory = function (component) {
+	var index = this.history.findIndex(function (item) {
+		return item.component === component;
+	});
+
+	if (index > -1) {
+		this.history.splice(index, 1);
+		if (index <= this.index) {
+			this.index--;
+		}
+
+		this.clearComponentHistory(component);
+	}
+};
+
+History.prototype.undo = function () {
+
+	if (this.index > -1) {
+		var action = this.history[this.index];
+
+		this.undoers[action.type].call(this, action);
+
+		this.index--;
+
+		this.table.options.historyUndo.call(this.table, action.type, action.component.getComponent(), action.data);
+
+		return true;
+	} else {
+		console.warn("History Undo Error - No more history to undo");
+		return false;
+	}
+};
+
+History.prototype.redo = function () {
+	if (this.history.length - 1 > this.index) {
+
+		this.index++;
+
+		var action = this.history[this.index];
+
+		this.redoers[action.type].call(this, action);
+
+		this.table.options.historyRedo.call(this.table, action.type, action.component.getComponent(), action.data);
+
+		return true;
+	} else {
+		console.warn("History Redo Error - No more history to redo");
+		return false;
+	}
+};
+
+History.prototype.undoers = {
+	cellEdit: function cellEdit(action) {
+		action.component.setValueProcessData(action.data.oldValue);
+	},
+
+	rowAdd: function rowAdd(action) {
+		action.component.deleteActual();
+	},
+
+	rowDelete: function rowDelete(action) {
+		var newRow = this.table.rowManager.addRowActual(action.data.data, action.data.pos, action.data.index);
+
+		if (this.table.options.groupBy && this.table.modExists("groupRows")) {
+			this.table.modules.groupRows.updateGroupRows(true);
+		}
+
+		this._rebindRow(action.component, newRow);
+	},
+
+	rowMove: function rowMove(action) {
+		this.table.rowManager.moveRowActual(action.component, this.table.rowManager.rows[action.data.posFrom], !action.data.after);
+		this.table.rowManager.redraw();
+	}
+};
+
+History.prototype.redoers = {
+	cellEdit: function cellEdit(action) {
+		action.component.setValueProcessData(action.data.newValue);
+	},
+
+	rowAdd: function rowAdd(action) {
+		var newRow = this.table.rowManager.addRowActual(action.data.data, action.data.pos, action.data.index);
+
+		if (this.table.options.groupBy && this.table.modExists("groupRows")) {
+			this.table.modules.groupRows.updateGroupRows(true);
+		}
+
+		this._rebindRow(action.component, newRow);
+	},
+
+	rowDelete: function rowDelete(action) {
+		action.component.deleteActual();
+	},
+
+	rowMove: function rowMove(action) {
+		this.table.rowManager.moveRowActual(action.component, this.table.rowManager.rows[action.data.posTo], action.data.after);
+		this.table.rowManager.redraw();
+	}
+};
+
+//rebind rows to new element after deletion
+History.prototype._rebindRow = function (oldRow, newRow) {
+	this.history.forEach(function (action) {
+		if (action.component instanceof Row) {
+			if (action.component === oldRow) {
+				action.component = newRow;
+			}
+		} else if (action.component instanceof Cell) {
+			if (action.component.row === oldRow) {
+				var field = action.component.column.getField();
+
+				if (field) {
+					action.component = newRow.getCell(field);
+				}
+			}
+		}
+	});
+};
+
+Tabulator.prototype.registerModule("history", History);

public/assets/vendors/tabulator/js/modules/history.min.js

@@ -0,0 +1,2 @@
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+var History=function(t){this.table=t,this.history=[],this.index=-1};History.prototype.clear=function(){this.history=[],this.index=-1},History.prototype.action=function(t,o,e){this.history=this.history.slice(0,this.index+1),this.history.push({type:t,component:o,data:e}),this.index++},History.prototype.getHistoryUndoSize=function(){return this.index+1},History.prototype.getHistoryRedoSize=function(){return this.history.length-(this.index+1)},History.prototype.clearComponentHistory=function(t){var o=this.history.findIndex(function(o){return o.component===t});o>-1&&(this.history.splice(o,1),o<=this.index&&this.index--,this.clearComponentHistory(t))},History.prototype.undo=function(){if(this.index>-1){var t=this.history[this.index];return this.undoers[t.type].call(this,t),this.index--,this.table.options.historyUndo.call(this.table,t.type,t.component.getComponent(),t.data),!0}return console.warn("History Undo Error - No more history to undo"),!1},History.prototype.redo=function(){if(this.history.length-1>this.index){this.index++;var t=this.history[this.index];return this.redoers[t.type].call(this,t),this.table.options.historyRedo.call(this.table,t.type,t.component.getComponent(),t.data),!0}return console.warn("History Redo Error - No more history to redo"),!1},History.prototype.undoers={cellEdit:function(t){t.component.setValueProcessData(t.data.oldValue)},rowAdd:function(t){t.component.deleteActual()},rowDelete:function(t){var o=this.table.rowManager.addRowActual(t.data.data,t.data.pos,t.data.index);this.table.options.groupBy&&this.table.modExists("groupRows")&&this.table.modules.groupRows.updateGroupRows(!0),this._rebindRow(t.component,o)},rowMove:function(t){this.table.rowManager.moveRowActual(t.component,this.table.rowManager.rows[t.data.posFrom],!t.data.after),this.table.rowManager.redraw()}},History.prototype.redoers={cellEdit:function(t){t.component.setValueProcessData(t.data.newValue)},rowAdd:function(t){var o=this.table.rowManager.addRowActual(t.data.data,t.data.pos,t.data.index);this.table.options.groupBy&&this.table.modExists("groupRows")&&this.table.modules.groupRows.updateGroupRows(!0),this._rebindRow(t.component,o)},rowDelete:function(t){t.component.deleteActual()},rowMove:function(t){this.table.rowManager.moveRowActual(t.component,this.table.rowManager.rows[t.data.posTo],t.data.after),this.table.rowManager.redraw()}},History.prototype._rebindRow=function(t,o){this.history.forEach(function(e){if(e.component instanceof Row)e.component===t&&(e.component=o);else if(e.component instanceof Cell&&e.component.row===t){var i=e.component.column.getField();i&&(e.component=o.getCell(i))}})},Tabulator.prototype.registerModule("history",History);

public/assets/vendors/tabulator/js/modules/html_table_import.js

@@ -0,0 +1,191 @@
+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; };
+
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+
+var HtmlTableImport = function HtmlTableImport(table) {
+	this.table = table; //hold Tabulator object
+	this.fieldIndex = [];
+	this.hasIndex = false;
+};
+
+HtmlTableImport.prototype.parseTable = function () {
+	var self = this,
+	    element = self.table.element,
+	    options = self.table.options,
+	    columns = options.columns,
+	    headers = element.getElementsByTagName("th"),
+	    rows = element.getElementsByTagName("tbody")[0],
+	    data = [],
+	    newTable;
+
+	self.hasIndex = false;
+
+	self.table.options.htmlImporting.call(this.table);
+
+	rows = rows ? rows.getElementsByTagName("tr") : [];
+
+	//check for tablator inline options
+	self._extractOptions(element, options);
+
+	if (headers.length) {
+		self._extractHeaders(headers, rows);
+	} else {
+		self._generateBlankHeaders(headers, rows);
+	}
+
+	//iterate through table rows and build data set
+	for (var index = 0; index < rows.length; index++) {
+		var row = rows[index],
+		    cells = row.getElementsByTagName("td"),
+		    item = {};
+
+		//create index if the dont exist in table
+		if (!self.hasIndex) {
+			item[options.index] = index;
+		}
+
+		for (var i = 0; i < cells.length; i++) {
+			var cell = cells[i];
+			if (typeof this.fieldIndex[i] !== "undefined") {
+				item[this.fieldIndex[i]] = cell.innerHTML;
+			}
+		}
+
+		//add row data to item
+		data.push(item);
+	}
+
+	//create new element
+	var newElement = document.createElement("div");
+
+	//transfer attributes to new element
+	var attributes = element.attributes;
+
+	// loop through attributes and apply them on div
+
+	for (var i in attributes) {
+		if (_typeof(attributes[i]) == "object") {
+			newElement.setAttribute(attributes[i].name, attributes[i].value);
+		}
+	}
+
+	// replace table with div element
+	element.parentNode.replaceChild(newElement, element);
+
+	options.data = data;
+
+	self.table.options.htmlImported.call(this.table);
+
+	// // newElement.tabulator(options);
+
+	this.table.element = newElement;
+};
+
+//extract tabulator attribute options
+HtmlTableImport.prototype._extractOptions = function (element, options, defaultOptions) {
+	var attributes = element.attributes;
+	var optionsArr = defaultOptions ? Object.assign([], defaultOptions) : Object.keys(options);
+	var optionsList = {};
+
+	optionsArr.forEach(function (item) {
+		optionsList[item.toLowerCase()] = item;
+	});
+
+	for (var index in attributes) {
+		var attrib = attributes[index];
+		var name;
+
+		if (attrib && (typeof attrib === "undefined" ? "undefined" : _typeof(attrib)) == "object" && attrib.name && attrib.name.indexOf("tabulator-") === 0) {
+			name = attrib.name.replace("tabulator-", "");
+
+			if (typeof optionsList[name] !== "undefined") {
+				options[optionsList[name]] = this._attribValue(attrib.value);
+			}
+		}
+	}
+};
+
+//get value of attribute
+HtmlTableImport.prototype._attribValue = function (value) {
+	if (value === "true") {
+		return true;
+	}
+
+	if (value === "false") {
+		return false;
+	}
+
+	return value;
+};
+
+//find column if it has already been defined
+HtmlTableImport.prototype._findCol = function (title) {
+	var match = this.table.options.columns.find(function (column) {
+		return column.title === title;
+	});
+
+	return match || false;
+};
+
+//extract column from headers
+HtmlTableImport.prototype._extractHeaders = function (headers, rows) {
+	for (var index = 0; index < headers.length; index++) {
+		var header = headers[index],
+		    exists = false,
+		    col = this._findCol(header.textContent),
+		    width,
+		    attributes;
+
+		if (col) {
+			exists = true;
+		} else {
+			col = { title: header.textContent.trim() };
+		}
+
+		if (!col.field) {
+			col.field = header.textContent.trim().toLowerCase().replace(" ", "_");
+		}
+
+		width = header.getAttribute("width");
+
+		if (width && !col.width) {
+			col.width = width;
+		}
+
+		//check for tablator inline options
+		attributes = header.attributes;
+
+		// //check for tablator inline options
+		this._extractOptions(header, col, Column.prototype.defaultOptionList);
+
+		this.fieldIndex[index] = col.field;
+
+		if (col.field == this.table.options.index) {
+			this.hasIndex = true;
+		}
+
+		if (!exists) {
+			this.table.options.columns.push(col);
+		}
+	}
+};
+
+//generate blank headers
+HtmlTableImport.prototype._generateBlankHeaders = function (headers, rows) {
+	for (var index = 0; index < headers.length; index++) {
+		var header = headers[index],
+		    col = { title: "", field: "col" + index };
+
+		this.fieldIndex[index] = col.field;
+
+		var width = header.getAttribute("width");
+
+		if (width) {
+			col.width = width;
+		}
+
+		this.table.options.columns.push(col);
+	}
+};
+
+Tabulator.prototype.registerModule("htmlTableImport", HtmlTableImport);

public/assets/vendors/tabulator/js/modules/html_table_import.min.js

@@ -0,0 +1,2 @@
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+var _typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},HtmlTableImport=function(t){this.table=t,this.fieldIndex=[],this.hasIndex=!1};HtmlTableImport.prototype.parseTable=function(){var t=this,e=t.table.element,o=t.table.options,a=(o.columns,e.getElementsByTagName("th")),n=e.getElementsByTagName("tbody")[0],l=[];t.hasIndex=!1,t.table.options.htmlImporting.call(this.table),n=n?n.getElementsByTagName("tr"):[],t._extractOptions(e,o),a.length?t._extractHeaders(a,n):t._generateBlankHeaders(a,n);for(var r=0;r<n.length;r++){var i=n[r],s=i.getElementsByTagName("td"),p={};t.hasIndex||(p[o.index]=r);for(var m=0;m<s.length;m++){var d=s[m];void 0!==this.fieldIndex[m]&&(p[this.fieldIndex[m]]=d.innerHTML)}l.push(p)}var f=document.createElement("div"),b=e.attributes;for(var m in b)"object"==_typeof(b[m])&&f.setAttribute(b[m].name,b[m].value);e.parentNode.replaceChild(f,e),o.data=l,t.table.options.htmlImported.call(this.table),this.table.element=f},HtmlTableImport.prototype._extractOptions=function(t,e,o){var a=t.attributes,n=o?Object.assign([],o):Object.keys(e),l={};n.forEach(function(t){l[t.toLowerCase()]=t});for(var r in a){var i,s=a[r];s&&"object"==(void 0===s?"undefined":_typeof(s))&&s.name&&0===s.name.indexOf("tabulator-")&&(i=s.name.replace("tabulator-",""),void 0!==l[i]&&(e[l[i]]=this._attribValue(s.value)))}},HtmlTableImport.prototype._attribValue=function(t){return"true"===t||"false"!==t&&t},HtmlTableImport.prototype._findCol=function(t){return this.table.options.columns.find(function(e){return e.title===t})||!1},HtmlTableImport.prototype._extractHeaders=function(t,e){for(var o=0;o<t.length;o++){var a,n=t[o],l=!1,r=this._findCol(n.textContent);r?l=!0:r={title:n.textContent.trim()},r.field||(r.field=n.textContent.trim().toLowerCase().replace(" ","_")),a=n.getAttribute("width"),a&&!r.width&&(r.width=a),n.attributes,this._extractOptions(n,r,Column.prototype.defaultOptionList),this.fieldIndex[o]=r.field,r.field==this.table.options.index&&(this.hasIndex=!0),l||this.table.options.columns.push(r)}},HtmlTableImport.prototype._generateBlankHeaders=function(t,e){for(var o=0;o<t.length;o++){var a=t[o],n={title:"",field:"col"+o};this.fieldIndex[o]=n.field;var l=a.getAttribute("width");l&&(n.width=l),this.table.options.columns.push(n)}},Tabulator.prototype.registerModule("htmlTableImport",HtmlTableImport);

public/assets/vendors/tabulator/js/modules/keybindings.js

@@ -0,0 +1,392 @@
+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; };
+
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+
+var Keybindings = function Keybindings(table) {
+	this.table = table; //hold Tabulator object
+	this.watchKeys = null;
+	this.pressedKeys = null;
+	this.keyupBinding = false;
+	this.keydownBinding = false;
+};
+
+Keybindings.prototype.initialize = function () {
+	var bindings = this.table.options.keybindings,
+	    mergedBindings = {};
+
+	this.watchKeys = {};
+	this.pressedKeys = [];
+
+	if (bindings !== false) {
+
+		for (var key in this.bindings) {
+			mergedBindings[key] = this.bindings[key];
+		}
+
+		if (Object.keys(bindings).length) {
+
+			for (var _key in bindings) {
+				mergedBindings[_key] = bindings[_key];
+			}
+		}
+
+		this.mapBindings(mergedBindings);
+		this.bindEvents();
+	}
+};
+
+Keybindings.prototype.mapBindings = function (bindings) {
+	var _this = this;
+
+	var self = this;
+
+	var _loop = function _loop(key) {
+
+		if (_this.actions[key]) {
+
+			if (bindings[key]) {
+
+				if (_typeof(bindings[key]) !== "object") {
+					bindings[key] = [bindings[key]];
+				}
+
+				bindings[key].forEach(function (binding) {
+					self.mapBinding(key, binding);
+				});
+			}
+		} else {
+			console.warn("Key Binding Error - no such action:", key);
+		}
+	};
+
+	for (var key in bindings) {
+		_loop(key);
+	}
+};
+
+Keybindings.prototype.mapBinding = function (action, symbolsList) {
+	var self = this;
+
+	var binding = {
+		action: this.actions[action],
+		keys: [],
+		ctrl: false,
+		shift: false,
+		meta: false
+	};
+
+	var symbols = symbolsList.toString().toLowerCase().split(" ").join("").split("+");
+
+	symbols.forEach(function (symbol) {
+		switch (symbol) {
+			case "ctrl":
+				binding.ctrl = true;
+				break;
+
+			case "shift":
+				binding.shift = true;
+				break;
+
+			case "meta":
+				binding.meta = true;
+				break;
+
+			default:
+				symbol = parseInt(symbol);
+				binding.keys.push(symbol);
+
+				if (!self.watchKeys[symbol]) {
+					self.watchKeys[symbol] = [];
+				}
+
+				self.watchKeys[symbol].push(binding);
+		}
+	});
+};
+
+Keybindings.prototype.bindEvents = function () {
+	var self = this;
+
+	this.keyupBinding = function (e) {
+		var code = e.keyCode;
+		var bindings = self.watchKeys[code];
+
+		if (bindings) {
+
+			self.pressedKeys.push(code);
+
+			bindings.forEach(function (binding) {
+				self.checkBinding(e, binding);
+			});
+		}
+	};
+
+	this.keydownBinding = function (e) {
+		var code = e.keyCode;
+		var bindings = self.watchKeys[code];
+
+		if (bindings) {
+
+			var index = self.pressedKeys.indexOf(code);
+
+			if (index > -1) {
+				self.pressedKeys.splice(index, 1);
+			}
+		}
+	};
+
+	this.table.element.addEventListener("keydown", this.keyupBinding);
+
+	this.table.element.addEventListener("keyup", this.keydownBinding);
+};
+
+Keybindings.prototype.clearBindings = function () {
+	if (this.keyupBinding) {
+		this.table.element.removeEventListener("keydown", this.keyupBinding);
+	}
+
+	if (this.keydownBinding) {
+		this.table.element.removeEventListener("keyup", this.keydownBinding);
+	}
+};
+
+Keybindings.prototype.checkBinding = function (e, binding) {
+	var self = this,
+	    match = true;
+
+	if (e.ctrlKey == binding.ctrl && e.shiftKey == binding.shift && e.metaKey == binding.meta) {
+		binding.keys.forEach(function (key) {
+			var index = self.pressedKeys.indexOf(key);
+
+			if (index == -1) {
+				match = false;
+			}
+		});
+
+		if (match) {
+			binding.action.call(self, e);
+		}
+
+		return true;
+	}
+
+	return false;
+};
+
+//default bindings
+Keybindings.prototype.bindings = {
+	navPrev: "shift + 9",
+	navNext: 9,
+	navUp: 38,
+	navDown: 40,
+	scrollPageUp: 33,
+	scrollPageDown: 34,
+	scrollToStart: 36,
+	scrollToEnd: 35,
+	undo: "ctrl + 90",
+	redo: "ctrl + 89",
+	copyToClipboard: "ctrl + 67"
+};
+
+//default actions
+Keybindings.prototype.actions = {
+	keyBlock: function keyBlock(e) {
+		e.stopPropagation();
+		e.preventDefault();
+	},
+	scrollPageUp: function scrollPageUp(e) {
+		var rowManager = this.table.rowManager,
+		    newPos = rowManager.scrollTop - rowManager.height,
+		    scrollMax = rowManager.element.scrollHeight;
+
+		e.preventDefault();
+
+		if (rowManager.displayRowsCount) {
+			if (newPos >= 0) {
+				rowManager.element.scrollTop = newPos;
+			} else {
+				rowManager.scrollToRow(rowManager.getDisplayRows()[0]);
+			}
+		}
+
+		this.table.element.focus();
+	},
+	scrollPageDown: function scrollPageDown(e) {
+		var rowManager = this.table.rowManager,
+		    newPos = rowManager.scrollTop + rowManager.height,
+		    scrollMax = rowManager.element.scrollHeight;
+
+		e.preventDefault();
+
+		if (rowManager.displayRowsCount) {
+			if (newPos <= scrollMax) {
+				rowManager.element.scrollTop = newPos;
+			} else {
+				rowManager.scrollToRow(rowManager.getDisplayRows()[rowManager.displayRowsCount - 1]);
+			}
+		}
+
+		this.table.element.focus();
+	},
+	scrollToStart: function scrollToStart(e) {
+		var rowManager = this.table.rowManager;
+
+		e.preventDefault();
+
+		if (rowManager.displayRowsCount) {
+			rowManager.scrollToRow(rowManager.getDisplayRows()[0]);
+		}
+
+		this.table.element.focus();
+	},
+	scrollToEnd: function scrollToEnd(e) {
+		var rowManager = this.table.rowManager;
+
+		e.preventDefault();
+
+		if (rowManager.displayRowsCount) {
+			rowManager.scrollToRow(rowManager.getDisplayRows()[rowManager.displayRowsCount - 1]);
+		}
+
+		this.table.element.focus();
+	},
+	navPrev: function navPrev(e) {
+		var cell = false;
+
+		if (this.table.modExists("edit")) {
+			cell = this.table.modules.edit.currentCell;
+
+			if (cell) {
+				e.preventDefault();
+				cell.nav().prev();
+			}
+		}
+	},
+
+	navNext: function navNext(e) {
+		var cell = false;
+		var newRow = this.table.options.tabEndNewRow;
+		var nav;
+
+		if (this.table.modExists("edit")) {
+			cell = this.table.modules.edit.currentCell;
+
+			if (cell) {
+				e.preventDefault();
+
+				nav = cell.nav();
+
+				if (!nav.next()) {
+					if (newRow) {
+
+						cell.getElement().firstChild.blur();
+
+						if (newRow === true) {
+							newRow = this.table.addRow({});
+						} else {
+							if (typeof newRow == "function") {
+								newRow = this.table.addRow(newRow(cell.row.getComponent()));
+							} else {
+								newRow = this.table.addRow(Object.assign({}, newRow));
+							}
+						}
+
+						newRow.then(function () {
+							setTimeout(function () {
+								nav.next();
+							});
+						});
+					}
+				}
+			}
+		}
+	},
+
+	navLeft: function navLeft(e) {
+		var cell = false;
+
+		if (this.table.modExists("edit")) {
+			cell = this.table.modules.edit.currentCell;
+
+			if (cell) {
+				e.preventDefault();
+				cell.nav().left();
+			}
+		}
+	},
+
+	navRight: function navRight(e) {
+		var cell = false;
+
+		if (this.table.modExists("edit")) {
+			cell = this.table.modules.edit.currentCell;
+
+			if (cell) {
+				e.preventDefault();
+				cell.nav().right();
+			}
+		}
+	},
+
+	navUp: function navUp(e) {
+		var cell = false;
+
+		if (this.table.modExists("edit")) {
+			cell = this.table.modules.edit.currentCell;
+
+			if (cell) {
+				e.preventDefault();
+				cell.nav().up();
+			}
+		}
+	},
+
+	navDown: function navDown(e) {
+		var cell = false;
+
+		if (this.table.modExists("edit")) {
+			cell = this.table.modules.edit.currentCell;
+
+			if (cell) {
+				e.preventDefault();
+				cell.nav().down();
+			}
+		}
+	},
+
+	undo: function undo(e) {
+		var cell = false;
+		if (this.table.options.history && this.table.modExists("history") && this.table.modExists("edit")) {
+
+			cell = this.table.modules.edit.currentCell;
+
+			if (!cell) {
+				e.preventDefault();
+				this.table.modules.history.undo();
+			}
+		}
+	},
+
+	redo: function redo(e) {
+		var cell = false;
+		if (this.table.options.history && this.table.modExists("history") && this.table.modExists("edit")) {
+
+			cell = this.table.modules.edit.currentCell;
+
+			if (!cell) {
+				e.preventDefault();
+				this.table.modules.history.redo();
+			}
+		}
+	},
+
+	copyToClipboard: function copyToClipboard(e) {
+		if (!this.table.modules.edit.currentCell) {
+			if (this.table.modExists("clipboard", true)) {
+				this.table.modules.clipboard.copy(false, true);
+			}
+		}
+	}
+};
+
+Tabulator.prototype.registerModule("keybindings", Keybindings);

public/assets/vendors/tabulator/js/modules/keybindings.min.js

@@ -0,0 +1,2 @@
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+var _typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},Keybindings=function(t){this.table=t,this.watchKeys=null,this.pressedKeys=null,this.keyupBinding=!1,this.keydownBinding=!1};Keybindings.prototype.initialize=function(){var t=this.table.options.keybindings,e={};if(this.watchKeys={},this.pressedKeys=[],!1!==t){for(var i in this.bindings)e[i]=this.bindings[i];if(Object.keys(t).length)for(var n in t)e[n]=t[n];this.mapBindings(e),this.bindEvents()}},Keybindings.prototype.mapBindings=function(t){var e=this,i=this;for(var n in t)!function(n){e.actions[n]?t[n]&&("object"!==_typeof(t[n])&&(t[n]=[t[n]]),t[n].forEach(function(t){i.mapBinding(n,t)})):console.warn("Key Binding Error - no such action:",n)}(n)},Keybindings.prototype.mapBinding=function(t,e){var i=this,n={action:this.actions[t],keys:[],ctrl:!1,shift:!1,meta:!1};e.toString().toLowerCase().split(" ").join("").split("+").forEach(function(t){switch(t){case"ctrl":n.ctrl=!0;break;case"shift":n.shift=!0;break;case"meta":n.meta=!0;break;default:t=parseInt(t),n.keys.push(t),i.watchKeys[t]||(i.watchKeys[t]=[]),i.watchKeys[t].push(n)}})},Keybindings.prototype.bindEvents=function(){var t=this;this.keyupBinding=function(e){var i=e.keyCode,n=t.watchKeys[i];n&&(t.pressedKeys.push(i),n.forEach(function(i){t.checkBinding(e,i)}))},this.keydownBinding=function(e){var i=e.keyCode;if(t.watchKeys[i]){var n=t.pressedKeys.indexOf(i);n>-1&&t.pressedKeys.splice(n,1)}},this.table.element.addEventListener("keydown",this.keyupBinding),this.table.element.addEventListener("keyup",this.keydownBinding)},Keybindings.prototype.clearBindings=function(){this.keyupBinding&&this.table.element.removeEventListener("keydown",this.keyupBinding),this.keydownBinding&&this.table.element.removeEventListener("keyup",this.keydownBinding)},Keybindings.prototype.checkBinding=function(t,e){var i=this,n=!0;return t.ctrlKey==e.ctrl&&t.shiftKey==e.shift&&t.metaKey==e.meta&&(e.keys.forEach(function(t){-1==i.pressedKeys.indexOf(t)&&(n=!1)}),n&&e.action.call(i,t),!0)},Keybindings.prototype.bindings={navPrev:"shift + 9",navNext:9,navUp:38,navDown:40,scrollPageUp:33,scrollPageDown:34,scrollToStart:36,scrollToEnd:35,undo:"ctrl + 90",redo:"ctrl + 89",copyToClipboard:"ctrl + 67"},Keybindings.prototype.actions={keyBlock:function(t){t.stopPropagation(),t.preventDefault()},scrollPageUp:function(t){var e=this.table.rowManager,i=e.scrollTop-e.height;e.element.scrollHeight;t.preventDefault(),e.displayRowsCount&&(i>=0?e.element.scrollTop=i:e.scrollToRow(e.getDisplayRows()[0])),this.table.element.focus()},scrollPageDown:function(t){var e=this.table.rowManager,i=e.scrollTop+e.height,n=e.element.scrollHeight;t.preventDefault(),e.displayRowsCount&&(i<=n?e.element.scrollTop=i:e.scrollToRow(e.getDisplayRows()[e.displayRowsCount-1])),this.table.element.focus()},scrollToStart:function(t){var e=this.table.rowManager;t.preventDefault(),e.displayRowsCount&&e.scrollToRow(e.getDisplayRows()[0]),this.table.element.focus()},scrollToEnd:function(t){var e=this.table.rowManager;t.preventDefault(),e.displayRowsCount&&e.scrollToRow(e.getDisplayRows()[e.displayRowsCount-1]),this.table.element.focus()},navPrev:function(t){var e=!1;this.table.modExists("edit")&&(e=this.table.modules.edit.currentCell)&&(t.preventDefault(),e.nav().prev())},navNext:function(t){var e,i=!1,n=this.table.options.tabEndNewRow;this.table.modExists("edit")&&(i=this.table.modules.edit.currentCell)&&(t.preventDefault(),e=i.nav(),e.next()||n&&(i.getElement().firstChild.blur(),n=!0===n?this.table.addRow({}):"function"==typeof n?this.table.addRow(n(i.row.getComponent())):this.table.addRow(Object.assign({},n)),n.then(function(){setTimeout(function(){e.next()})})))},navLeft:function(t){var e=!1;this.table.modExists("edit")&&(e=this.table.modules.edit.currentCell)&&(t.preventDefault(),e.nav().left())},navRight:function(t){var e=!1;this.table.modExists("edit")&&(e=this.table.modules.edit.currentCell)&&(t.preventDefault(),e.nav().right())},navUp:function(t){var e=!1;this.table.modExists("edit")&&(e=this.table.modules.edit.currentCell)&&(t.preventDefault(),e.nav().up())},navDown:function(t){var e=!1;this.table.modExists("edit")&&(e=this.table.modules.edit.currentCell)&&(t.preventDefault(),e.nav().down())},undo:function(t){this.table.options.history&&this.table.modExists("history")&&this.table.modExists("edit")&&(this.table.modules.edit.currentCell||(t.preventDefault(),this.table.modules.history.undo()))},redo:function(t){this.table.options.history&&this.table.modExists("history")&&this.table.modExists("edit")&&(this.table.modules.edit.currentCell||(t.preventDefault(),this.table.modules.history.redo()))},copyToClipboard:function(t){this.table.modules.edit.currentCell||this.table.modExists("clipboard",!0)&&this.table.modules.clipboard.copy(!1,!0)}},Tabulator.prototype.registerModule("keybindings",Keybindings);

public/assets/vendors/tabulator/js/modules/menu.js

@@ -0,0 +1,310 @@
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+
+var Menu = function Menu(table) {
+	this.table = table; //hold Tabulator object
+	this.menuElements = [];
+	this.blurEvent = this.hideMenu.bind(this);
+	this.escEvent = this.escMenu.bind(this);
+	this.nestedMenuBlock = false;
+	this.positionReversedX = false;
+};
+
+Menu.prototype.initializeColumnHeader = function (column) {
+	var _this = this;
+
+	var headerMenuEl;
+
+	if (column.definition.headerContextMenu) {
+		column.getElement().addEventListener("contextmenu", this.LoadMenuEvent.bind(this, column, column.definition.headerContextMenu));
+		this.tapHold(column, column.definition.headerContextMenu);
+	}
+
+	// if(column.definition.headerClickMenu){
+	// 	column.getElement().addEventListener("click", this.LoadMenuEvent.bind(this, column, column.definition.headerClickMenu));
+	// }
+
+	if (column.definition.headerMenu) {
+
+		headerMenuEl = document.createElement("span");
+		headerMenuEl.classList.add("tabulator-header-menu-button");
+		headerMenuEl.innerHTML = "⋮";
+
+		headerMenuEl.addEventListener("click", function (e) {
+			e.stopPropagation();
+			e.preventDefault();
+
+			_this.LoadMenuEvent(column, column.definition.headerMenu, e);
+		});
+
+		column.titleElement.insertBefore(headerMenuEl, column.titleElement.firstChild);
+	}
+};
+
+Menu.prototype.LoadMenuEvent = function (component, menu, e) {
+	menu = typeof menu == "function" ? menu.call(this.table, component.getComponent(), e) : menu;
+
+	// if(component instanceof Cell){
+	// 	e.stopImmediatePropagation();
+	// }
+
+	this.loadMenu(e, component, menu);
+};
+
+Menu.prototype.tapHold = function (component, menu) {
+	var _this2 = this;
+
+	var element = component.getElement(),
+	    tapHold = null,
+	    loaded = false;
+
+	element.addEventListener("touchstart", function (e) {
+		clearTimeout(tapHold);
+		loaded = false;
+
+		tapHold = setTimeout(function () {
+			clearTimeout(tapHold);
+			tapHold = null;
+			loaded = true;
+
+			_this2.LoadMenuEvent(component, menu, e);
+		}, 1000);
+	}, { passive: true });
+
+	element.addEventListener("touchend", function (e) {
+		clearTimeout(tapHold);
+		tapHold = null;
+
+		if (loaded) {
+			e.preventDefault();
+		}
+	});
+};
+
+Menu.prototype.initializeCell = function (cell) {
+	if (cell.column.definition.contextMenu) {
+		cell.getElement(true).addEventListener("contextmenu", this.LoadMenuEvent.bind(this, cell, cell.column.definition.contextMenu));
+		this.tapHold(cell, cell.column.definition.contextMenu);
+	}
+
+	if (cell.column.definition.clickMenu) {
+		cell.getElement(true).addEventListener("click", this.LoadMenuEvent.bind(this, cell, cell.column.definition.clickMenu));
+	}
+};
+
+Menu.prototype.initializeRow = function (row) {
+	if (this.table.options.rowContextMenu) {
+		row.getElement().addEventListener("contextmenu", this.LoadMenuEvent.bind(this, row, this.table.options.rowContextMenu));
+		this.tapHold(row, this.table.options.rowContextMenu);
+	}
+
+	if (this.table.options.rowClickMenu) {
+		row.getElement().addEventListener("click", this.LoadMenuEvent.bind(this, row, this.table.options.rowClickMenu));
+	}
+};
+
+Menu.prototype.initializeGroup = function (group) {
+	if (this.table.options.groupContextMenu) {
+		group.getElement().addEventListener("contextmenu", this.LoadMenuEvent.bind(this, group, this.table.options.groupContextMenu));
+		this.tapHold(group, this.table.options.groupContextMenu);
+	}
+
+	if (this.table.options.groupClickMenu) {
+		group.getElement().addEventListener("click", this.LoadMenuEvent.bind(this, group, this.table.options.groupClickMenu));
+	}
+};
+
+Menu.prototype.loadMenu = function (e, component, menu, parentEl) {
+	var _this3 = this;
+
+	var touch = !(e instanceof MouseEvent);
+
+	var menuEl = document.createElement("div");
+	menuEl.classList.add("tabulator-menu");
+
+	if (!touch) {
+		e.preventDefault();
+	}
+
+	//abort if no menu set
+	if (!menu || !menu.length) {
+		return;
+	}
+
+	if (!parentEl) {
+		if (this.nestedMenuBlock) {
+			//abort if child menu already open
+			if (this.isOpen()) {
+				return;
+			}
+		} else {
+			this.nestedMenuBlock = setTimeout(function () {
+				_this3.nestedMenuBlock = false;
+			}, 100);
+		}
+
+		this.hideMenu();
+		this.menuElements = [];
+	}
+
+	menu.forEach(function (item) {
+		var itemEl = document.createElement("div"),
+		    label = item.label,
+		    disabled = item.disabled;
+
+		if (item.separator) {
+			itemEl.classList.add("tabulator-menu-separator");
+		} else {
+			itemEl.classList.add("tabulator-menu-item");
+
+			if (typeof label == "function") {
+				label = label.call(_this3.table, component.getComponent());
+			}
+
+			if (label instanceof Node) {
+				itemEl.appendChild(label);
+			} else {
+				itemEl.innerHTML = label;
+			}
+
+			if (typeof disabled == "function") {
+				disabled = disabled.call(_this3.table, component.getComponent());
+			}
+
+			if (disabled) {
+				itemEl.classList.add("tabulator-menu-item-disabled");
+				itemEl.addEventListener("click", function (e) {
+					e.stopPropagation();
+				});
+			} else {
+				if (item.menu && item.menu.length) {
+					itemEl.addEventListener("click", function (e) {
+						e.stopPropagation();
+						_this3.hideOldSubMenus(menuEl);
+						_this3.loadMenu(e, component, item.menu, itemEl);
+					});
+				} else {
+					if (item.action) {
+						itemEl.addEventListener("click", function (e) {
+							item.action(e, component.getComponent());
+						});
+					}
+				}
+			}
+
+			if (item.menu && item.menu.length) {
+				itemEl.classList.add("tabulator-menu-item-submenu");
+			}
+		}
+
+		menuEl.appendChild(itemEl);
+	});
+
+	menuEl.addEventListener("click", function (e) {
+		_this3.hideMenu();
+	});
+
+	this.menuElements.push(menuEl);
+	this.positionMenu(menuEl, parentEl, touch, e);
+};
+
+Menu.prototype.hideOldSubMenus = function (menuEl) {
+	var index = this.menuElements.indexOf(menuEl);
+
+	if (index > -1) {
+		for (var i = this.menuElements.length - 1; i > index; i--) {
+			var el = this.menuElements[i];
+
+			if (el.parentNode) {
+				el.parentNode.removeChild(el);
+			}
+
+			this.menuElements.pop();
+		}
+	}
+};
+
+Menu.prototype.positionMenu = function (element, parentEl, touch, e) {
+	var _this4 = this;
+
+	var docHeight = Math.max(document.body.offsetHeight, window.innerHeight),
+	    x,
+	    y,
+	    parentOffset;
+
+	if (!parentEl) {
+		x = touch ? e.touches[0].pageX : e.pageX;
+		y = touch ? e.touches[0].pageY : e.pageY;
+
+		this.positionReversedX = false;
+	} else {
+		parentOffset = Tabulator.prototype.helpers.elOffset(parentEl);
+		x = parentOffset.left + parentEl.offsetWidth;
+		y = parentOffset.top - 1;
+	}
+
+	element.style.top = y + "px";
+	element.style.left = x + "px";
+
+	setTimeout(function () {
+		_this4.table.rowManager.element.addEventListener("scroll", _this4.blurEvent);
+		document.body.addEventListener("click", _this4.blurEvent);
+		document.body.addEventListener("contextmenu", _this4.blurEvent);
+		window.addEventListener("resize", _this4.blurEvent);
+		document.body.addEventListener("keydown", _this4.escEvent);
+	}, 100);
+
+	document.body.appendChild(element);
+
+	//move menu to start on bottom edge if it is too close to the edge of the screen
+	if (y + element.offsetHeight >= docHeight) {
+		element.style.top = "";
+
+		if (parentEl) {
+			element.style.bottom = docHeight - parentOffset.top - parentEl.offsetHeight - 1 + "px";
+		} else {
+			element.style.bottom = docHeight - y + "px";
+		}
+	}
+
+	//move menu to start on right edge if it is too close to the edge of the screen
+	if (x + element.offsetWidth >= document.body.offsetWidth || this.positionReversedX) {
+		element.style.left = "";
+
+		if (parentEl) {
+			element.style.right = document.documentElement.offsetWidth - parentOffset.left + "px";
+		} else {
+			element.style.right = document.documentElement.offsetWidth - x + "px";
+		}
+
+		this.positionReversedX = true;
+	}
+};
+
+Menu.prototype.isOpen = function () {
+	return !!this.menuElements.length;
+};
+
+Menu.prototype.escMenu = function (e) {
+	if (e.keyCode == 27) {
+		this.hideMenu();
+	}
+};
+
+Menu.prototype.hideMenu = function () {
+	this.menuElements.forEach(function (menuEl) {
+		if (menuEl.parentNode) {
+			menuEl.parentNode.removeChild(menuEl);
+		}
+	});
+
+	document.body.removeEventListener("keydown", this.escEvent);
+	document.body.removeEventListener("click", this.blurEvent);
+	document.body.removeEventListener("contextmenu", this.blurEvent);
+	window.removeEventListener("resize", this.blurEvent);
+	this.table.rowManager.element.removeEventListener("scroll", this.blurEvent);
+};
+
+//default accessors
+Menu.prototype.menus = {};
+
+Tabulator.prototype.registerModule("menu", Menu);

public/assets/vendors/tabulator/js/modules/moveable_columns.js

@@ -0,0 +1,289 @@
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+
+var MoveColumns = function MoveColumns(table) {
+	this.table = table; //hold Tabulator object
+	this.placeholderElement = this.createPlaceholderElement();
+	this.hoverElement = false; //floating column header element
+	this.checkTimeout = false; //click check timeout holder
+	this.checkPeriod = 250; //period to wait on mousedown to consider this a move and not a click
+	this.moving = false; //currently moving column
+	this.toCol = false; //destination column
+	this.toColAfter = false; //position of moving column relative to the desitnation column
+	this.startX = 0; //starting position within header element
+	this.autoScrollMargin = 40; //auto scroll on edge when within margin
+	this.autoScrollStep = 5; //auto scroll distance in pixels
+	this.autoScrollTimeout = false; //auto scroll timeout
+	this.touchMove = false;
+
+	this.moveHover = this.moveHover.bind(this);
+	this.endMove = this.endMove.bind(this);
+};
+
+MoveColumns.prototype.createPlaceholderElement = function () {
+	var el = document.createElement("div");
+
+	el.classList.add("tabulator-col");
+	el.classList.add("tabulator-col-placeholder");
+
+	return el;
+};
+
+MoveColumns.prototype.initializeColumn = function (column) {
+	var self = this,
+	    config = {},
+	    colEl;
+
+	if (!column.modules.frozen) {
+
+		colEl = column.getElement();
+
+		config.mousemove = function (e) {
+			if (column.parent === self.moving.parent) {
+				if ((self.touchMove ? e.touches[0].pageX : e.pageX) - Tabulator.prototype.helpers.elOffset(colEl).left + self.table.columnManager.element.scrollLeft > column.getWidth() / 2) {
+					if (self.toCol !== column || !self.toColAfter) {
+						colEl.parentNode.insertBefore(self.placeholderElement, colEl.nextSibling);
+						self.moveColumn(column, true);
+					}
+				} else {
+					if (self.toCol !== column || self.toColAfter) {
+						colEl.parentNode.insertBefore(self.placeholderElement, colEl);
+						self.moveColumn(column, false);
+					}
+				}
+			}
+		}.bind(self);
+
+		colEl.addEventListener("mousedown", function (e) {
+			self.touchMove = false;
+			if (e.which === 1) {
+				self.checkTimeout = setTimeout(function () {
+					self.startMove(e, column);
+				}, self.checkPeriod);
+			}
+		});
+
+		colEl.addEventListener("mouseup", function (e) {
+			if (e.which === 1) {
+				if (self.checkTimeout) {
+					clearTimeout(self.checkTimeout);
+				}
+			}
+		});
+
+		self.bindTouchEvents(column);
+	}
+
+	column.modules.moveColumn = config;
+};
+
+MoveColumns.prototype.bindTouchEvents = function (column) {
+	var self = this,
+	    colEl = column.getElement(),
+	    startXMove = false,
+	    //shifting center position of the cell
+	dir = false,
+	    currentCol,
+	    nextCol,
+	    prevCol,
+	    nextColWidth,
+	    prevColWidth,
+	    nextColWidthLast,
+	    prevColWidthLast;
+
+	colEl.addEventListener("touchstart", function (e) {
+		self.checkTimeout = setTimeout(function () {
+			self.touchMove = true;
+			currentCol = column;
+			nextCol = column.nextColumn();
+			nextColWidth = nextCol ? nextCol.getWidth() / 2 : 0;
+			prevCol = column.prevColumn();
+			prevColWidth = prevCol ? prevCol.getWidth() / 2 : 0;
+			nextColWidthLast = 0;
+			prevColWidthLast = 0;
+			startXMove = false;
+
+			self.startMove(e, column);
+		}, self.checkPeriod);
+	}, { passive: true });
+
+	colEl.addEventListener("touchmove", function (e) {
+		var halfCol, diff, moveToCol;
+
+		if (self.moving) {
+			self.moveHover(e);
+
+			if (!startXMove) {
+				startXMove = e.touches[0].pageX;
+			}
+
+			diff = e.touches[0].pageX - startXMove;
+
+			if (diff > 0) {
+				if (nextCol && diff - nextColWidthLast > nextColWidth) {
+					moveToCol = nextCol;
+
+					if (moveToCol !== column) {
+						startXMove = e.touches[0].pageX;
+						moveToCol.getElement().parentNode.insertBefore(self.placeholderElement, moveToCol.getElement().nextSibling);
+						self.moveColumn(moveToCol, true);
+					}
+				}
+			} else {
+				if (prevCol && -diff - prevColWidthLast > prevColWidth) {
+					moveToCol = prevCol;
+
+					if (moveToCol !== column) {
+						startXMove = e.touches[0].pageX;
+						moveToCol.getElement().parentNode.insertBefore(self.placeholderElement, moveToCol.getElement());
+						self.moveColumn(moveToCol, false);
+					}
+				}
+			}
+
+			if (moveToCol) {
+				currentCol = moveToCol;
+				nextCol = moveToCol.nextColumn();
+				nextColWidthLast = nextColWidth;
+				nextColWidth = nextCol ? nextCol.getWidth() / 2 : 0;
+				prevCol = moveToCol.prevColumn();
+				prevColWidthLast = prevColWidth;
+				prevColWidth = prevCol ? prevCol.getWidth() / 2 : 0;
+			}
+		}
+	}, { passive: true });
+
+	colEl.addEventListener("touchend", function (e) {
+		if (self.checkTimeout) {
+			clearTimeout(self.checkTimeout);
+		}
+		if (self.moving) {
+			self.endMove(e);
+		}
+	});
+};
+
+MoveColumns.prototype.startMove = function (e, column) {
+	var element = column.getElement();
+
+	this.moving = column;
+	this.startX = (this.touchMove ? e.touches[0].pageX : e.pageX) - Tabulator.prototype.helpers.elOffset(element).left;
+
+	this.table.element.classList.add("tabulator-block-select");
+
+	//create placeholder
+	this.placeholderElement.style.width = column.getWidth() + "px";
+	this.placeholderElement.style.height = column.getHeight() + "px";
+
+	element.parentNode.insertBefore(this.placeholderElement, element);
+	element.parentNode.removeChild(element);
+
+	//create hover element
+	this.hoverElement = element.cloneNode(true);
+	this.hoverElement.classList.add("tabulator-moving");
+
+	this.table.columnManager.getElement().appendChild(this.hoverElement);
+
+	this.hoverElement.style.left = "0";
+	this.hoverElement.style.bottom = "0";
+
+	if (!this.touchMove) {
+		this._bindMouseMove();
+
+		document.body.addEventListener("mousemove", this.moveHover);
+		document.body.addEventListener("mouseup", this.endMove);
+	}
+
+	this.moveHover(e);
+};
+
+MoveColumns.prototype._bindMouseMove = function () {
+	this.table.columnManager.columnsByIndex.forEach(function (column) {
+		if (column.modules.moveColumn.mousemove) {
+			column.getElement().addEventListener("mousemove", column.modules.moveColumn.mousemove);
+		}
+	});
+};
+
+MoveColumns.prototype._unbindMouseMove = function () {
+	this.table.columnManager.columnsByIndex.forEach(function (column) {
+		if (column.modules.moveColumn.mousemove) {
+			column.getElement().removeEventListener("mousemove", column.modules.moveColumn.mousemove);
+		}
+	});
+};
+
+MoveColumns.prototype.moveColumn = function (column, after) {
+	var movingCells = this.moving.getCells();
+
+	this.toCol = column;
+	this.toColAfter = after;
+
+	if (after) {
+		column.getCells().forEach(function (cell, i) {
+			var cellEl = cell.getElement(true);
+			cellEl.parentNode.insertBefore(movingCells[i].getElement(), cellEl.nextSibling);
+		});
+	} else {
+		column.getCells().forEach(function (cell, i) {
+			var cellEl = cell.getElement(true);
+			cellEl.parentNode.insertBefore(movingCells[i].getElement(), cellEl);
+		});
+	}
+};
+
+MoveColumns.prototype.endMove = function (e) {
+	if (e.which === 1 || this.touchMove) {
+		this._unbindMouseMove();
+
+		this.placeholderElement.parentNode.insertBefore(this.moving.getElement(), this.placeholderElement.nextSibling);
+		this.placeholderElement.parentNode.removeChild(this.placeholderElement);
+		this.hoverElement.parentNode.removeChild(this.hoverElement);
+
+		this.table.element.classList.remove("tabulator-block-select");
+
+		if (this.toCol) {
+			this.table.columnManager.moveColumnActual(this.moving, this.toCol, this.toColAfter);
+		}
+
+		this.moving = false;
+		this.toCol = false;
+		this.toColAfter = false;
+
+		if (!this.touchMove) {
+			document.body.removeEventListener("mousemove", this.moveHover);
+			document.body.removeEventListener("mouseup", this.endMove);
+		}
+	}
+};
+
+MoveColumns.prototype.moveHover = function (e) {
+	var self = this,
+	    columnHolder = self.table.columnManager.getElement(),
+	    scrollLeft = columnHolder.scrollLeft,
+	    xPos = (self.touchMove ? e.touches[0].pageX : e.pageX) - Tabulator.prototype.helpers.elOffset(columnHolder).left + scrollLeft,
+	    scrollPos;
+
+	self.hoverElement.style.left = xPos - self.startX + "px";
+
+	if (xPos - scrollLeft < self.autoScrollMargin) {
+		if (!self.autoScrollTimeout) {
+			self.autoScrollTimeout = setTimeout(function () {
+				scrollPos = Math.max(0, scrollLeft - 5);
+				self.table.rowManager.getElement().scrollLeft = scrollPos;
+				self.autoScrollTimeout = false;
+			}, 1);
+		}
+	}
+
+	if (scrollLeft + columnHolder.clientWidth - xPos < self.autoScrollMargin) {
+		if (!self.autoScrollTimeout) {
+			self.autoScrollTimeout = setTimeout(function () {
+				scrollPos = Math.min(columnHolder.clientWidth, scrollLeft + 5);
+				self.table.rowManager.getElement().scrollLeft = scrollPos;
+				self.autoScrollTimeout = false;
+			}, 1);
+		}
+	}
+};
+
+Tabulator.prototype.registerModule("moveColumn", MoveColumns);

public/assets/vendors/tabulator/js/modules/moveable_rows.js

@@ -0,0 +1,634 @@
+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; };
+
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+
+var MoveRows = function MoveRows(table) {
+
+	this.table = table; //hold Tabulator object
+	this.placeholderElement = this.createPlaceholderElement();
+	this.hoverElement = false; //floating row header element
+	this.checkTimeout = false; //click check timeout holder
+	this.checkPeriod = 150; //period to wait on mousedown to consider this a move and not a click
+	this.moving = false; //currently moving row
+	this.toRow = false; //destination row
+	this.toRowAfter = false; //position of moving row relative to the desitnation row
+	this.hasHandle = false; //row has handle instead of fully movable row
+	this.startY = 0; //starting Y position within header element
+	this.startX = 0; //starting X position within header element
+
+	this.moveHover = this.moveHover.bind(this);
+	this.endMove = this.endMove.bind(this);
+	this.tableRowDropEvent = false;
+
+	this.touchMove = false;
+
+	this.connection = false;
+	this.connectionSelectorsTables = false;
+	this.connectionSelectorsElements = false;
+	this.connectionElements = [];
+	this.connections = [];
+
+	this.connectedTable = false;
+	this.connectedRow = false;
+};
+
+MoveRows.prototype.createPlaceholderElement = function () {
+	var el = document.createElement("div");
+
+	el.classList.add("tabulator-row");
+	el.classList.add("tabulator-row-placeholder");
+
+	return el;
+};
+
+MoveRows.prototype.initialize = function (handle) {
+	this.connectionSelectorsTables = this.table.options.movableRowsConnectedTables;
+	this.connectionSelectorsElements = this.table.options.movableRowsConnectedElements;
+
+	this.connection = this.connectionSelectorsTables || this.connectionSelectorsElements;
+};
+
+MoveRows.prototype.setHandle = function (handle) {
+	this.hasHandle = handle;
+};
+
+MoveRows.prototype.initializeGroupHeader = function (group) {
+	var self = this,
+	    config = {},
+	    rowEl;
+
+	//inter table drag drop
+	config.mouseup = function (e) {
+		self.tableRowDrop(e, row);
+	}.bind(self);
+
+	//same table drag drop
+	config.mousemove = function (e) {
+		if (e.pageY - Tabulator.prototype.helpers.elOffset(group.element).top + self.table.rowManager.element.scrollTop > group.getHeight() / 2) {
+			if (self.toRow !== group || !self.toRowAfter) {
+				var rowEl = group.getElement();
+				rowEl.parentNode.insertBefore(self.placeholderElement, rowEl.nextSibling);
+				self.moveRow(group, true);
+			}
+		} else {
+			if (self.toRow !== group || self.toRowAfter) {
+				var rowEl = group.getElement();
+				if (rowEl.previousSibling) {
+					rowEl.parentNode.insertBefore(self.placeholderElement, rowEl);
+					self.moveRow(group, false);
+				}
+			}
+		}
+	}.bind(self);
+
+	group.modules.moveRow = config;
+};
+
+MoveRows.prototype.initializeRow = function (row) {
+	var self = this,
+	    config = {},
+	    rowEl;
+
+	//inter table drag drop
+	config.mouseup = function (e) {
+		self.tableRowDrop(e, row);
+	}.bind(self);
+
+	//same table drag drop
+	config.mousemove = function (e) {
+		var rowEl = row.getElement();
+
+		if (e.pageY - Tabulator.prototype.helpers.elOffset(rowEl).top + self.table.rowManager.element.scrollTop > row.getHeight() / 2) {
+			if (self.toRow !== row || !self.toRowAfter) {
+				rowEl.parentNode.insertBefore(self.placeholderElement, rowEl.nextSibling);
+				self.moveRow(row, true);
+			}
+		} else {
+			if (self.toRow !== row || self.toRowAfter) {
+				rowEl.parentNode.insertBefore(self.placeholderElement, rowEl);
+				self.moveRow(row, false);
+			}
+		}
+	}.bind(self);
+
+	if (!this.hasHandle) {
+
+		rowEl = row.getElement();
+
+		rowEl.addEventListener("mousedown", function (e) {
+			if (e.which === 1) {
+				self.checkTimeout = setTimeout(function () {
+					self.startMove(e, row);
+				}, self.checkPeriod);
+			}
+		});
+
+		rowEl.addEventListener("mouseup", function (e) {
+			if (e.which === 1) {
+				if (self.checkTimeout) {
+					clearTimeout(self.checkTimeout);
+				}
+			}
+		});
+
+		this.bindTouchEvents(row, row.getElement());
+	}
+
+	row.modules.moveRow = config;
+};
+
+MoveRows.prototype.initializeCell = function (cell) {
+	var self = this,
+	    cellEl = cell.getElement(true);
+
+	cellEl.addEventListener("mousedown", function (e) {
+		if (e.which === 1) {
+			self.checkTimeout = setTimeout(function () {
+				self.startMove(e, cell.row);
+			}, self.checkPeriod);
+		}
+	});
+
+	cellEl.addEventListener("mouseup", function (e) {
+		if (e.which === 1) {
+			if (self.checkTimeout) {
+				clearTimeout(self.checkTimeout);
+			}
+		}
+	});
+
+	this.bindTouchEvents(cell.row, cellEl);
+};
+
+MoveRows.prototype.bindTouchEvents = function (row, element) {
+	var self = this,
+	    startYMove = false,
+	    //shifting center position of the cell
+	dir = false,
+	    currentRow,
+	    nextRow,
+	    prevRow,
+	    nextRowHeight,
+	    prevRowHeight,
+	    nextRowHeightLast,
+	    prevRowHeightLast;
+
+	element.addEventListener("touchstart", function (e) {
+		self.checkTimeout = setTimeout(function () {
+			self.touchMove = true;
+			currentRow = row;
+			nextRow = row.nextRow();
+			nextRowHeight = nextRow ? nextRow.getHeight() / 2 : 0;
+			prevRow = row.prevRow();
+			prevRowHeight = prevRow ? prevRow.getHeight() / 2 : 0;
+			nextRowHeightLast = 0;
+			prevRowHeightLast = 0;
+			startYMove = false;
+
+			self.startMove(e, row);
+		}, self.checkPeriod);
+	}, { passive: true });
+	this.moving, this.toRow, this.toRowAfter;
+	element.addEventListener("touchmove", function (e) {
+
+		var halfCol, diff, moveToRow;
+
+		if (self.moving) {
+			e.preventDefault();
+
+			self.moveHover(e);
+
+			if (!startYMove) {
+				startYMove = e.touches[0].pageY;
+			}
+
+			diff = e.touches[0].pageY - startYMove;
+
+			if (diff > 0) {
+				if (nextRow && diff - nextRowHeightLast > nextRowHeight) {
+					moveToRow = nextRow;
+
+					if (moveToRow !== row) {
+						startYMove = e.touches[0].pageY;
+						moveToRow.getElement().parentNode.insertBefore(self.placeholderElement, moveToRow.getElement().nextSibling);
+						self.moveRow(moveToRow, true);
+					}
+				}
+			} else {
+				if (prevRow && -diff - prevRowHeightLast > prevRowHeight) {
+					moveToRow = prevRow;
+
+					if (moveToRow !== row) {
+						startYMove = e.touches[0].pageY;
+						moveToRow.getElement().parentNode.insertBefore(self.placeholderElement, moveToRow.getElement());
+						self.moveRow(moveToRow, false);
+					}
+				}
+			}
+
+			if (moveToRow) {
+				currentRow = moveToRow;
+				nextRow = moveToRow.nextRow();
+				nextRowHeightLast = nextRowHeight;
+				nextRowHeight = nextRow ? nextRow.getHeight() / 2 : 0;
+				prevRow = moveToRow.prevRow();
+				prevRowHeightLast = prevRowHeight;
+				prevRowHeight = prevRow ? prevRow.getHeight() / 2 : 0;
+			}
+		}
+	});
+
+	element.addEventListener("touchend", function (e) {
+		if (self.checkTimeout) {
+			clearTimeout(self.checkTimeout);
+		}
+		if (self.moving) {
+			self.endMove(e);
+			self.touchMove = false;
+		}
+	});
+};
+
+MoveRows.prototype._bindMouseMove = function () {
+	var self = this;
+
+	self.table.rowManager.getDisplayRows().forEach(function (row) {
+		if ((row.type === "row" || row.type === "group") && row.modules.moveRow.mousemove) {
+			row.getElement().addEventListener("mousemove", row.modules.moveRow.mousemove);
+		}
+	});
+};
+
+MoveRows.prototype._unbindMouseMove = function () {
+	var self = this;
+
+	self.table.rowManager.getDisplayRows().forEach(function (row) {
+		if ((row.type === "row" || row.type === "group") && row.modules.moveRow.mousemove) {
+			row.getElement().removeEventListener("mousemove", row.modules.moveRow.mousemove);
+		}
+	});
+};
+
+MoveRows.prototype.startMove = function (e, row) {
+	var element = row.getElement();
+
+	this.setStartPosition(e, row);
+
+	this.moving = row;
+
+	this.table.element.classList.add("tabulator-block-select");
+
+	//create placeholder
+	this.placeholderElement.style.width = row.getWidth() + "px";
+	this.placeholderElement.style.height = row.getHeight() + "px";
+
+	if (!this.connection) {
+		element.parentNode.insertBefore(this.placeholderElement, element);
+		element.parentNode.removeChild(element);
+	} else {
+		this.table.element.classList.add("tabulator-movingrow-sending");
+		this.connectToTables(row);
+	}
+
+	//create hover element
+	this.hoverElement = element.cloneNode(true);
+	this.hoverElement.classList.add("tabulator-moving");
+
+	if (this.connection) {
+		document.body.appendChild(this.hoverElement);
+		this.hoverElement.style.left = "0";
+		this.hoverElement.style.top = "0";
+		this.hoverElement.style.width = this.table.element.clientWidth + "px";
+		this.hoverElement.style.whiteSpace = "nowrap";
+		this.hoverElement.style.overflow = "hidden";
+		this.hoverElement.style.pointerEvents = "none";
+	} else {
+		this.table.rowManager.getTableElement().appendChild(this.hoverElement);
+
+		this.hoverElement.style.left = "0";
+		this.hoverElement.style.top = "0";
+
+		this._bindMouseMove();
+	}
+
+	document.body.addEventListener("mousemove", this.moveHover);
+	document.body.addEventListener("mouseup", this.endMove);
+
+	this.moveHover(e);
+};
+
+MoveRows.prototype.setStartPosition = function (e, row) {
+	var pageX = this.touchMove ? e.touches[0].pageX : e.pageX,
+	    pageY = this.touchMove ? e.touches[0].pageY : e.pageY,
+	    element,
+	    position;
+
+	element = row.getElement();
+	if (this.connection) {
+		position = element.getBoundingClientRect();
+
+		this.startX = position.left - pageX + window.pageXOffset;
+		this.startY = position.top - pageY + window.pageYOffset;
+	} else {
+		this.startY = pageY - element.getBoundingClientRect().top;
+	}
+};
+
+MoveRows.prototype.endMove = function (e) {
+	if (!e || e.which === 1 || this.touchMove) {
+		this._unbindMouseMove();
+
+		if (!this.connection) {
+			this.placeholderElement.parentNode.insertBefore(this.moving.getElement(), this.placeholderElement.nextSibling);
+			this.placeholderElement.parentNode.removeChild(this.placeholderElement);
+		}
+
+		this.hoverElement.parentNode.removeChild(this.hoverElement);
+
+		this.table.element.classList.remove("tabulator-block-select");
+
+		if (this.toRow) {
+			this.table.rowManager.moveRow(this.moving, this.toRow, this.toRowAfter);
+		}
+
+		this.moving = false;
+		this.toRow = false;
+		this.toRowAfter = false;
+
+		document.body.removeEventListener("mousemove", this.moveHover);
+		document.body.removeEventListener("mouseup", this.endMove);
+
+		if (this.connection) {
+			this.table.element.classList.remove("tabulator-movingrow-sending");
+			this.disconnectFromTables();
+		}
+	}
+};
+
+MoveRows.prototype.moveRow = function (row, after) {
+	this.toRow = row;
+	this.toRowAfter = after;
+};
+
+MoveRows.prototype.moveHover = function (e) {
+	if (this.connection) {
+		this.moveHoverConnections.call(this, e);
+	} else {
+		this.moveHoverTable.call(this, e);
+	}
+};
+
+MoveRows.prototype.moveHoverTable = function (e) {
+	var rowHolder = this.table.rowManager.getElement(),
+	    scrollTop = rowHolder.scrollTop,
+	    yPos = (this.touchMove ? e.touches[0].pageY : e.pageY) - rowHolder.getBoundingClientRect().top + scrollTop,
+	    scrollPos;
+
+	this.hoverElement.style.top = yPos - this.startY + "px";
+};
+
+MoveRows.prototype.moveHoverConnections = function (e) {
+	this.hoverElement.style.left = this.startX + (this.touchMove ? e.touches[0].pageX : e.pageX) + "px";
+	this.hoverElement.style.top = this.startY + (this.touchMove ? e.touches[0].pageY : e.pageY) + "px";
+};
+
+MoveRows.prototype.elementRowDrop = function (e, element, row) {
+	if (this.table.options.movableRowsElementDrop) {
+		this.table.options.movableRowsElementDrop(e, element, row ? row.getComponent() : false);
+	}
+};
+
+//establish connection with other tables
+MoveRows.prototype.connectToTables = function (row) {
+	var _this = this;
+
+	var connectionTables;
+
+	if (this.connectionSelectorsTables) {
+		connectionTables = this.table.modules.comms.getConnections(this.connectionSelectorsTables);
+
+		this.table.options.movableRowsSendingStart.call(this.table, connectionTables);
+
+		this.table.modules.comms.send(this.connectionSelectorsTables, "moveRow", "connect", {
+			row: row
+		});
+	}
+
+	if (this.connectionSelectorsElements) {
+
+		this.connectionElements = [];
+
+		if (!Array.isArray(this.connectionSelectorsElements)) {
+			this.connectionSelectorsElements = [this.connectionSelectorsElements];
+		}
+
+		this.connectionSelectorsElements.forEach(function (query) {
+			if (typeof query === "string") {
+				_this.connectionElements = _this.connectionElements.concat(Array.prototype.slice.call(document.querySelectorAll(query)));
+			} else {
+				_this.connectionElements.push(query);
+			}
+		});
+
+		this.connectionElements.forEach(function (element) {
+			var dropEvent = function dropEvent(e) {
+				_this.elementRowDrop(e, element, _this.moving);
+			};
+
+			element.addEventListener("mouseup", dropEvent);
+			element.tabulatorElementDropEvent = dropEvent;
+
+			element.classList.add("tabulator-movingrow-receiving");
+		});
+	}
+};
+
+//disconnect from other tables
+MoveRows.prototype.disconnectFromTables = function () {
+	var connectionTables;
+
+	if (this.connectionSelectorsTables) {
+		connectionTables = this.table.modules.comms.getConnections(this.connectionSelectorsTables);
+
+		this.table.options.movableRowsSendingStop.call(this.table, connectionTables);
+
+		this.table.modules.comms.send(this.connectionSelectorsTables, "moveRow", "disconnect");
+	}
+
+	this.connectionElements.forEach(function (element) {
+		element.classList.remove("tabulator-movingrow-receiving");
+		element.removeEventListener("mouseup", element.tabulatorElementDropEvent);
+		delete element.tabulatorElementDropEvent;
+	});
+};
+
+//accept incomming connection
+MoveRows.prototype.connect = function (table, row) {
+	var self = this;
+	if (!this.connectedTable) {
+		this.connectedTable = table;
+		this.connectedRow = row;
+
+		this.table.element.classList.add("tabulator-movingrow-receiving");
+
+		self.table.rowManager.getDisplayRows().forEach(function (row) {
+			if (row.type === "row" && row.modules.moveRow && row.modules.moveRow.mouseup) {
+				row.getElement().addEventListener("mouseup", row.modules.moveRow.mouseup);
+			}
+		});
+
+		self.tableRowDropEvent = self.tableRowDrop.bind(self);
+
+		self.table.element.addEventListener("mouseup", self.tableRowDropEvent);
+
+		this.table.options.movableRowsReceivingStart.call(this.table, row, table);
+
+		return true;
+	} else {
+		console.warn("Move Row Error - Table cannot accept connection, already connected to table:", this.connectedTable);
+		return false;
+	}
+};
+
+//close incomming connection
+MoveRows.prototype.disconnect = function (table) {
+	var self = this;
+	if (table === this.connectedTable) {
+		this.connectedTable = false;
+		this.connectedRow = false;
+
+		this.table.element.classList.remove("tabulator-movingrow-receiving");
+
+		self.table.rowManager.getDisplayRows().forEach(function (row) {
+			if (row.type === "row" && row.modules.moveRow && row.modules.moveRow.mouseup) {
+				row.getElement().removeEventListener("mouseup", row.modules.moveRow.mouseup);
+			}
+		});
+
+		self.table.element.removeEventListener("mouseup", self.tableRowDropEvent);
+
+		this.table.options.movableRowsReceivingStop.call(this.table, table);
+	} else {
+		console.warn("Move Row Error - trying to disconnect from non connected table");
+	}
+};
+
+MoveRows.prototype.dropComplete = function (table, row, success) {
+	var sender = false;
+
+	if (success) {
+
+		switch (_typeof(this.table.options.movableRowsSender)) {
+			case "string":
+				sender = this.senders[this.table.options.movableRowsSender];
+				break;
+
+			case "function":
+				sender = this.table.options.movableRowsSender;
+				break;
+		}
+
+		if (sender) {
+			sender.call(this, this.moving.getComponent(), row ? row.getComponent() : undefined, table);
+		} else {
+			if (this.table.options.movableRowsSender) {
+				console.warn("Mover Row Error - no matching sender found:", this.table.options.movableRowsSender);
+			}
+		}
+
+		this.table.options.movableRowsSent.call(this.table, this.moving.getComponent(), row ? row.getComponent() : undefined, table);
+	} else {
+		this.table.options.movableRowsSentFailed.call(this.table, this.moving.getComponent(), row ? row.getComponent() : undefined, table);
+	}
+
+	this.endMove();
+};
+
+MoveRows.prototype.tableRowDrop = function (e, row) {
+	var receiver = false,
+	    success = false;
+
+	e.stopImmediatePropagation();
+
+	switch (_typeof(this.table.options.movableRowsReceiver)) {
+		case "string":
+			receiver = this.receivers[this.table.options.movableRowsReceiver];
+			break;
+
+		case "function":
+			receiver = this.table.options.movableRowsReceiver;
+			break;
+	}
+
+	if (receiver) {
+		success = receiver.call(this, this.connectedRow.getComponent(), row ? row.getComponent() : undefined, this.connectedTable);
+	} else {
+		console.warn("Mover Row Error - no matching receiver found:", this.table.options.movableRowsReceiver);
+	}
+
+	if (success) {
+		this.table.options.movableRowsReceived.call(this.table, this.connectedRow.getComponent(), row ? row.getComponent() : undefined, this.connectedTable);
+	} else {
+		this.table.options.movableRowsReceivedFailed.call(this.table, this.connectedRow.getComponent(), row ? row.getComponent() : undefined, this.connectedTable);
+	}
+
+	this.table.modules.comms.send(this.connectedTable, "moveRow", "dropcomplete", {
+		row: row,
+		success: success
+	});
+};
+
+MoveRows.prototype.receivers = {
+	insert: function insert(fromRow, toRow, fromTable) {
+		this.table.addRow(fromRow.getData(), undefined, toRow);
+		return true;
+	},
+
+	add: function add(fromRow, toRow, fromTable) {
+		this.table.addRow(fromRow.getData());
+		return true;
+	},
+
+	update: function update(fromRow, toRow, fromTable) {
+		if (toRow) {
+			toRow.update(fromRow.getData());
+			return true;
+		}
+
+		return false;
+	},
+
+	replace: function replace(fromRow, toRow, fromTable) {
+		if (toRow) {
+			this.table.addRow(fromRow.getData(), undefined, toRow);
+			toRow.delete();
+			return true;
+		}
+
+		return false;
+	}
+};
+
+MoveRows.prototype.senders = {
+	delete: function _delete(fromRow, toRow, toTable) {
+		fromRow.delete();
+	}
+};
+
+MoveRows.prototype.commsReceived = function (table, action, data) {
+	switch (action) {
+		case "connect":
+			return this.connect(table, data.row);
+			break;
+
+		case "disconnect":
+			return this.disconnect(table);
+			break;
+
+		case "dropcomplete":
+			return this.dropComplete(table, data.row, data.success);
+			break;
+	}
+};
+
+Tabulator.prototype.registerModule("moveRow", MoveRows);

public/assets/vendors/tabulator/js/modules/mutator.js

@@ -0,0 +1,116 @@
+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; };
+
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+
+var Mutator = function Mutator(table) {
+	this.table = table; //hold Tabulator object
+	this.allowedTypes = ["", "data", "edit", "clipboard"]; //list of muatation types
+	this.enabled = true;
+};
+
+//initialize column mutator
+Mutator.prototype.initializeColumn = function (column) {
+	var self = this,
+	    match = false,
+	    config = {};
+
+	this.allowedTypes.forEach(function (type) {
+		var key = "mutator" + (type.charAt(0).toUpperCase() + type.slice(1)),
+		    mutator;
+
+		if (column.definition[key]) {
+			mutator = self.lookupMutator(column.definition[key]);
+
+			if (mutator) {
+				match = true;
+
+				config[key] = {
+					mutator: mutator,
+					params: column.definition[key + "Params"] || {}
+				};
+			}
+		}
+	});
+
+	if (match) {
+		column.modules.mutate = config;
+	}
+};
+
+Mutator.prototype.lookupMutator = function (value) {
+	var mutator = false;
+
+	//set column mutator
+	switch (typeof value === "undefined" ? "undefined" : _typeof(value)) {
+		case "string":
+			if (this.mutators[value]) {
+				mutator = this.mutators[value];
+			} else {
+				console.warn("Mutator Error - No such mutator found, ignoring: ", value);
+			}
+			break;
+
+		case "function":
+			mutator = value;
+			break;
+	}
+
+	return mutator;
+};
+
+//apply mutator to row
+Mutator.prototype.transformRow = function (data, type, updatedData) {
+	var self = this,
+	    key = "mutator" + (type.charAt(0).toUpperCase() + type.slice(1)),
+	    value;
+
+	if (this.enabled) {
+
+		self.table.columnManager.traverse(function (column) {
+			var mutator, params, component;
+
+			if (column.modules.mutate) {
+				mutator = column.modules.mutate[key] || column.modules.mutate.mutator || false;
+
+				if (mutator) {
+					value = column.getFieldValue(typeof updatedData !== "undefined" ? updatedData : data);
+
+					if (type == "data" || typeof value !== "undefined") {
+						component = column.getComponent();
+						params = typeof mutator.params === "function" ? mutator.params(value, data, type, component) : mutator.params;
+						column.setFieldValue(data, mutator.mutator(value, data, type, params, component));
+					}
+				}
+			}
+		});
+	}
+
+	return data;
+};
+
+//apply mutator to new cell value
+Mutator.prototype.transformCell = function (cell, value) {
+	var mutator = cell.column.modules.mutate.mutatorEdit || cell.column.modules.mutate.mutator || false,
+	    tempData = {};
+
+	if (mutator) {
+		tempData = Object.assign(tempData, cell.row.getData());
+		cell.column.setFieldValue(tempData, value);
+		return mutator.mutator(value, tempData, "edit", mutator.params, cell.getComponent());
+	} else {
+		return value;
+	}
+};
+
+Mutator.prototype.enable = function () {
+	this.enabled = true;
+};
+
+Mutator.prototype.disable = function () {
+	this.enabled = false;
+};
+
+//default mutators
+Mutator.prototype.mutators = {};
+
+Tabulator.prototype.registerModule("mutator", Mutator);

public/assets/vendors/tabulator/js/modules/mutator.min.js

@@ -0,0 +1,2 @@
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+var _typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},Mutator=function(t){this.table=t,this.allowedTypes=["","data","edit","clipboard"],this.enabled=!0};Mutator.prototype.initializeColumn=function(t){var o=this,e=!1,a={};this.allowedTypes.forEach(function(r){var u,n="mutator"+(r.charAt(0).toUpperCase()+r.slice(1));t.definition[n]&&(u=o.lookupMutator(t.definition[n]))&&(e=!0,a[n]={mutator:u,params:t.definition[n+"Params"]||{}})}),e&&(t.modules.mutate=a)},Mutator.prototype.lookupMutator=function(t){var o=!1;switch(void 0===t?"undefined":_typeof(t)){case"string":this.mutators[t]?o=this.mutators[t]:console.warn("Mutator Error - No such mutator found, ignoring: ",t);break;case"function":o=t}return o},Mutator.prototype.transformRow=function(t,o,e){var a,r=this,u="mutator"+(o.charAt(0).toUpperCase()+o.slice(1));return this.enabled&&r.table.columnManager.traverse(function(r){var n,i,s;r.modules.mutate&&(n=r.modules.mutate[u]||r.modules.mutate.mutator||!1)&&(a=r.getFieldValue(void 0!==e?e:t),"data"!=o&&void 0===a||(s=r.getComponent(),i="function"==typeof n.params?n.params(a,t,o,s):n.params,r.setFieldValue(t,n.mutator(a,t,o,i,s))))}),t},Mutator.prototype.transformCell=function(t,o){var e=t.column.modules.mutate.mutatorEdit||t.column.modules.mutate.mutator||!1,a={};return e?(a=Object.assign(a,t.row.getData()),t.column.setFieldValue(a,o),e.mutator(o,a,"edit",e.params,t.getComponent())):o},Mutator.prototype.enable=function(){this.enabled=!0},Mutator.prototype.disable=function(){this.enabled=!1},Mutator.prototype.mutators={},Tabulator.prototype.registerModule("mutator",Mutator);

public/assets/vendors/tabulator/js/modules/page.js

@@ -0,0 +1,730 @@
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+
+var Page = function Page(table) {
+
+	this.table = table; //hold Tabulator object
+
+	this.mode = "local";
+	this.progressiveLoad = false;
+
+	this.size = 0;
+	this.page = 1;
+	this.count = 5;
+	this.max = 1;
+
+	this.displayIndex = 0; //index in display pipeline
+
+	this.initialLoad = true;
+
+	this.pageSizes = [];
+
+	this.dataReceivedNames = {};
+	this.dataSentNames = {};
+
+	this.createElements();
+};
+
+Page.prototype.createElements = function () {
+
+	var button;
+
+	this.element = document.createElement("span");
+	this.element.classList.add("tabulator-paginator");
+
+	this.pagesElement = document.createElement("span");
+	this.pagesElement.classList.add("tabulator-pages");
+
+	button = document.createElement("button");
+	button.classList.add("tabulator-page");
+	button.setAttribute("type", "button");
+	button.setAttribute("role", "button");
+	button.setAttribute("aria-label", "");
+	button.setAttribute("title", "");
+
+	this.firstBut = button.cloneNode(true);
+	this.firstBut.setAttribute("data-page", "first");
+
+	this.prevBut = button.cloneNode(true);
+	this.prevBut.setAttribute("data-page", "prev");
+
+	this.nextBut = button.cloneNode(true);
+	this.nextBut.setAttribute("data-page", "next");
+
+	this.lastBut = button.cloneNode(true);
+	this.lastBut.setAttribute("data-page", "last");
+
+	if (this.table.options.paginationSizeSelector) {
+		this.pageSizeSelect = document.createElement("select");
+		this.pageSizeSelect.classList.add("tabulator-page-size");
+	}
+};
+
+Page.prototype.generatePageSizeSelectList = function () {
+	var _this = this;
+
+	var pageSizes = [];
+
+	if (this.pageSizeSelect) {
+
+		if (Array.isArray(this.table.options.paginationSizeSelector)) {
+			pageSizes = this.table.options.paginationSizeSelector;
+			this.pageSizes = pageSizes;
+
+			if (this.pageSizes.indexOf(this.size) == -1) {
+				pageSizes.unshift(this.size);
+			}
+		} else {
+
+			if (this.pageSizes.indexOf(this.size) == -1) {
+				pageSizes = [];
+
+				for (var i = 1; i < 5; i++) {
+					pageSizes.push(this.size * i);
+				}
+
+				this.pageSizes = pageSizes;
+			} else {
+				pageSizes = this.pageSizes;
+			}
+		}
+
+		while (this.pageSizeSelect.firstChild) {
+			this.pageSizeSelect.removeChild(this.pageSizeSelect.firstChild);
+		}pageSizes.forEach(function (item) {
+			var itemEl = document.createElement("option");
+			itemEl.value = item;
+
+			if (item === true) {
+				_this.table.modules.localize.bind("pagination|all", function (value) {
+					itemEl.innerHTML = value;
+				});
+			} else {
+				itemEl.innerHTML = item;
+			}
+
+			_this.pageSizeSelect.appendChild(itemEl);
+		});
+
+		this.pageSizeSelect.value = this.size;
+	}
+};
+
+//setup pageination
+Page.prototype.initialize = function (hidden) {
+	var self = this,
+	    pageSelectLabel,
+	    testElRow,
+	    testElCell;
+
+	//update param names
+	this.dataSentNames = Object.assign({}, this.paginationDataSentNames);
+	this.dataSentNames = Object.assign(this.dataSentNames, this.table.options.paginationDataSent);
+
+	this.dataReceivedNames = Object.assign({}, this.paginationDataReceivedNames);
+	this.dataReceivedNames = Object.assign(this.dataReceivedNames, this.table.options.paginationDataReceived);
+
+	//build pagination element
+
+	//bind localizations
+	self.table.modules.localize.bind("pagination|first", function (value) {
+		self.firstBut.innerHTML = value;
+	});
+
+	self.table.modules.localize.bind("pagination|first_title", function (value) {
+		self.firstBut.setAttribute("aria-label", value);
+		self.firstBut.setAttribute("title", value);
+	});
+
+	self.table.modules.localize.bind("pagination|prev", function (value) {
+		self.prevBut.innerHTML = value;
+	});
+
+	self.table.modules.localize.bind("pagination|prev_title", function (value) {
+		self.prevBut.setAttribute("aria-label", value);
+		self.prevBut.setAttribute("title", value);
+	});
+
+	self.table.modules.localize.bind("pagination|next", function (value) {
+		self.nextBut.innerHTML = value;
+	});
+
+	self.table.modules.localize.bind("pagination|next_title", function (value) {
+		self.nextBut.setAttribute("aria-label", value);
+		self.nextBut.setAttribute("title", value);
+	});
+
+	self.table.modules.localize.bind("pagination|last", function (value) {
+		self.lastBut.innerHTML = value;
+	});
+
+	self.table.modules.localize.bind("pagination|last_title", function (value) {
+		self.lastBut.setAttribute("aria-label", value);
+		self.lastBut.setAttribute("title", value);
+	});
+
+	//click bindings
+	self.firstBut.addEventListener("click", function () {
+		self.setPage(1).then(function () {}).catch(function () {});
+	});
+
+	self.prevBut.addEventListener("click", function () {
+		self.previousPage().then(function () {}).catch(function () {});
+	});
+
+	self.nextBut.addEventListener("click", function () {
+		self.nextPage().then(function () {}).catch(function () {});
+	});
+
+	self.lastBut.addEventListener("click", function () {
+		self.setPage(self.max).then(function () {}).catch(function () {});
+	});
+
+	if (self.table.options.paginationElement) {
+		self.element = self.table.options.paginationElement;
+	}
+
+	if (this.pageSizeSelect) {
+		pageSelectLabel = document.createElement("label");
+
+		self.table.modules.localize.bind("pagination|page_size", function (value) {
+			self.pageSizeSelect.setAttribute("aria-label", value);
+			self.pageSizeSelect.setAttribute("title", value);
+			pageSelectLabel.innerHTML = value;
+		});
+
+		self.element.appendChild(pageSelectLabel);
+		self.element.appendChild(self.pageSizeSelect);
+
+		self.pageSizeSelect.addEventListener("change", function (e) {
+			self.setPageSize(self.pageSizeSelect.value == "true" ? true : self.pageSizeSelect.value);
+			self.setPage(1).then(function () {}).catch(function () {});
+		});
+	}
+
+	//append to DOM
+	self.element.appendChild(self.firstBut);
+	self.element.appendChild(self.prevBut);
+	self.element.appendChild(self.pagesElement);
+	self.element.appendChild(self.nextBut);
+	self.element.appendChild(self.lastBut);
+
+	if (!self.table.options.paginationElement && !hidden) {
+		self.table.footerManager.append(self.element, self);
+	}
+
+	//set default values
+	self.mode = self.table.options.pagination;
+
+	if (self.table.options.paginationSize) {
+		self.size = self.table.options.paginationSize;
+	} else {
+		testElRow = document.createElement("div");
+		testElRow.classList.add("tabulator-row");
+		testElRow.style.visibility = hidden;
+
+		testElCell = document.createElement("div");
+		testElCell.classList.add("tabulator-cell");
+		testElCell.innerHTML = "Page Row Test";
+
+		testElRow.appendChild(testElCell);
+
+		self.table.rowManager.getTableElement().appendChild(testElRow);
+
+		self.size = Math.floor(self.table.rowManager.getElement().clientHeight / testElRow.offsetHeight);
+
+		self.table.rowManager.getTableElement().removeChild(testElRow);
+	}
+
+	// self.page = self.table.options.paginationInitialPage || 1;
+	self.count = self.table.options.paginationButtonCount;
+
+	self.generatePageSizeSelectList();
+};
+
+Page.prototype.initializeProgressive = function (mode) {
+	this.initialize(true);
+	this.mode = "progressive_" + mode;
+	this.progressiveLoad = true;
+};
+
+Page.prototype.setDisplayIndex = function (index) {
+	this.displayIndex = index;
+};
+
+Page.prototype.getDisplayIndex = function () {
+	return this.displayIndex;
+};
+
+//calculate maximum page from number of rows
+Page.prototype.setMaxRows = function (rowCount) {
+	if (!rowCount) {
+		this.max = 1;
+	} else {
+		this.max = this.size === true ? 1 : Math.ceil(rowCount / this.size);
+	}
+
+	if (this.page > this.max) {
+		this.page = this.max;
+	}
+};
+
+//reset to first page without triggering action
+Page.prototype.reset = function (force, columnsChanged) {
+	if (this.mode == "local" || force) {
+		this.page = 1;
+	}
+
+	if (columnsChanged) {
+		this.initialLoad = true;
+	}
+
+	return true;
+};
+
+//set the maxmum page
+Page.prototype.setMaxPage = function (max) {
+
+	max = parseInt(max);
+
+	this.max = max || 1;
+
+	if (this.page > this.max) {
+		this.page = this.max;
+		this.trigger();
+	}
+};
+
+//set current page number
+Page.prototype.setPage = function (page) {
+	var _this2 = this;
+
+	var self = this;
+
+	switch (page) {
+		case "first":
+			return this.setPage(1);
+			break;
+
+		case "prev":
+			return this.previousPage();
+			break;
+
+		case "next":
+			return this.nextPage();
+			break;
+
+		case "last":
+			return this.setPage(this.max);
+			break;
+	}
+
+	return new Promise(function (resolve, reject) {
+
+		page = parseInt(page);
+
+		if (page > 0 && page <= _this2.max || _this2.mode !== "local") {
+			_this2.page = page;
+			_this2.trigger().then(function () {
+				resolve();
+			}).catch(function () {
+				reject();
+			});
+
+			if (self.table.options.persistence && self.table.modExists("persistence", true) && self.table.modules.persistence.config.page) {
+				self.table.modules.persistence.save("page");
+			}
+		} else {
+			console.warn("Pagination Error - Requested page is out of range of 1 - " + _this2.max + ":", page);
+			reject();
+		}
+	});
+};
+
+Page.prototype.setPageToRow = function (row) {
+	var _this3 = this;
+
+	return new Promise(function (resolve, reject) {
+
+		var rows = _this3.table.rowManager.getDisplayRows(_this3.displayIndex - 1);
+		var index = rows.indexOf(row);
+
+		if (index > -1) {
+			var page = _this3.size === true ? 1 : Math.ceil((index + 1) / _this3.size);
+
+			_this3.setPage(page).then(function () {
+				resolve();
+			}).catch(function () {
+				reject();
+			});
+		} else {
+			console.warn("Pagination Error - Requested row is not visible");
+			reject();
+		}
+	});
+};
+
+Page.prototype.setPageSize = function (size) {
+	if (size !== true) {
+		size = parseInt(size);
+	}
+
+	if (size > 0) {
+		this.size = size;
+	}
+
+	if (this.pageSizeSelect) {
+		// this.pageSizeSelect.value = size;
+		this.generatePageSizeSelectList();
+	}
+
+	if (this.table.options.persistence && this.table.modExists("persistence", true) && this.table.modules.persistence.config.page) {
+		this.table.modules.persistence.save("page");
+	}
+};
+
+//setup the pagination buttons
+Page.prototype._setPageButtons = function () {
+	var self = this;
+
+	var leftSize = Math.floor((this.count - 1) / 2);
+	var rightSize = Math.ceil((this.count - 1) / 2);
+	var min = this.max - this.page + leftSize + 1 < this.count ? this.max - this.count + 1 : Math.max(this.page - leftSize, 1);
+	var max = this.page <= rightSize ? Math.min(this.count, this.max) : Math.min(this.page + rightSize, this.max);
+
+	while (self.pagesElement.firstChild) {
+		self.pagesElement.removeChild(self.pagesElement.firstChild);
+	}if (self.page == 1) {
+		self.firstBut.disabled = true;
+		self.prevBut.disabled = true;
+	} else {
+		self.firstBut.disabled = false;
+		self.prevBut.disabled = false;
+	}
+
+	if (self.page == self.max) {
+		self.lastBut.disabled = true;
+		self.nextBut.disabled = true;
+	} else {
+		self.lastBut.disabled = false;
+		self.nextBut.disabled = false;
+	}
+
+	for (var i = min; i <= max; i++) {
+		if (i > 0 && i <= self.max) {
+			self.pagesElement.appendChild(self._generatePageButton(i));
+		}
+	}
+
+	this.footerRedraw();
+};
+
+Page.prototype._generatePageButton = function (page) {
+	var self = this,
+	    button = document.createElement("button");
+
+	button.classList.add("tabulator-page");
+	if (page == self.page) {
+		button.classList.add("active");
+	}
+
+	button.setAttribute("type", "button");
+	button.setAttribute("role", "button");
+
+	self.table.modules.localize.bind("pagination|page_title", function (value) {
+		button.setAttribute("aria-label", value + " " + page);
+		button.setAttribute("title", value + " " + page);
+	});
+
+	button.setAttribute("data-page", page);
+	button.textContent = page;
+
+	button.addEventListener("click", function (e) {
+		self.setPage(page).then(function () {}).catch(function () {});
+	});
+
+	return button;
+};
+
+//previous page
+Page.prototype.previousPage = function () {
+	var _this4 = this;
+
+	return new Promise(function (resolve, reject) {
+		if (_this4.page > 1) {
+			_this4.page--;
+			_this4.trigger().then(function () {
+				resolve();
+			}).catch(function () {
+				reject();
+			});
+
+			if (_this4.table.options.persistence && _this4.table.modExists("persistence", true) && _this4.table.modules.persistence.config.page) {
+				_this4.table.modules.persistence.save("page");
+			}
+		} else {
+			console.warn("Pagination Error - Previous page would be less than page 1:", 0);
+			reject();
+		}
+	});
+};
+
+//next page
+Page.prototype.nextPage = function () {
+	var _this5 = this;
+
+	return new Promise(function (resolve, reject) {
+		if (_this5.page < _this5.max) {
+			_this5.page++;
+			_this5.trigger().then(function () {
+				resolve();
+			}).catch(function () {
+				reject();
+			});
+
+			if (_this5.table.options.persistence && _this5.table.modExists("persistence", true) && _this5.table.modules.persistence.config.page) {
+				_this5.table.modules.persistence.save("page");
+			}
+		} else {
+			if (!_this5.progressiveLoad) {
+				console.warn("Pagination Error - Next page would be greater than maximum page of " + _this5.max + ":", _this5.max + 1);
+			}
+			reject();
+		}
+	});
+};
+
+//return current page number
+Page.prototype.getPage = function () {
+	return this.page;
+};
+
+//return max page number
+Page.prototype.getPageMax = function () {
+	return this.max;
+};
+
+Page.prototype.getPageSize = function (size) {
+	return this.size;
+};
+
+Page.prototype.getMode = function () {
+	return this.mode;
+};
+
+//return appropriate rows for current page
+Page.prototype.getRows = function (data) {
+	var output, start, end;
+
+	if (this.mode == "local") {
+		output = [];
+
+		if (this.size === true) {
+			start = 0;
+			end = data.length;
+		} else {
+			start = this.size * (this.page - 1);
+			end = start + parseInt(this.size);
+		}
+
+		this._setPageButtons();
+
+		for (var i = start; i < end; i++) {
+			if (data[i]) {
+				output.push(data[i]);
+			}
+		}
+
+		return output;
+	} else {
+
+		this._setPageButtons();
+
+		return data.slice(0);
+	}
+};
+
+Page.prototype.trigger = function () {
+	var _this6 = this;
+
+	var left;
+
+	return new Promise(function (resolve, reject) {
+
+		switch (_this6.mode) {
+			case "local":
+				left = _this6.table.rowManager.scrollLeft;
+
+				_this6.table.rowManager.refreshActiveData("page");
+				_this6.table.rowManager.scrollHorizontal(left);
+
+				_this6.table.options.pageLoaded.call(_this6.table, _this6.getPage());
+				resolve();
+				break;
+
+			case "remote":
+			case "progressive_load":
+			case "progressive_scroll":
+				_this6.table.modules.ajax.blockActiveRequest();
+				_this6._getRemotePage().then(function () {
+					resolve();
+				}).catch(function () {
+					reject();
+				});
+				break;
+
+			default:
+				console.warn("Pagination Error - no such pagination mode:", _this6.mode);
+				reject();
+		}
+	});
+};
+
+Page.prototype._getRemotePage = function () {
+	var _this7 = this;
+
+	var self = this,
+	    oldParams,
+	    pageParams;
+
+	return new Promise(function (resolve, reject) {
+
+		if (!self.table.modExists("ajax", true)) {
+			reject();
+		}
+
+		//record old params and restore after request has been made
+		oldParams = Tabulator.prototype.helpers.deepClone(self.table.modules.ajax.getParams() || {});
+		pageParams = self.table.modules.ajax.getParams();
+
+		//configure request params
+		pageParams[_this7.dataSentNames.page] = self.page;
+
+		//set page size if defined
+		if (_this7.size) {
+			pageParams[_this7.dataSentNames.size] = _this7.size;
+		}
+
+		//set sort data if defined
+		if (_this7.table.options.ajaxSorting && _this7.table.modExists("sort")) {
+			var sorters = self.table.modules.sort.getSort();
+
+			sorters.forEach(function (item) {
+				delete item.column;
+			});
+
+			pageParams[_this7.dataSentNames.sorters] = sorters;
+		}
+
+		//set filter data if defined
+		if (_this7.table.options.ajaxFiltering && _this7.table.modExists("filter")) {
+			var filters = self.table.modules.filter.getFilters(true, true);
+			pageParams[_this7.dataSentNames.filters] = filters;
+		}
+
+		self.table.modules.ajax.setParams(pageParams);
+
+		self.table.modules.ajax.sendRequest(_this7.progressiveLoad).then(function (data) {
+			self._parseRemoteData(data);
+			resolve();
+		}).catch(function (e) {
+			reject();
+		});
+
+		self.table.modules.ajax.setParams(oldParams);
+	});
+};
+
+Page.prototype._parseRemoteData = function (data) {
+	var self = this,
+	    left,
+	    data,
+	    margin;
+
+	if (typeof data[this.dataReceivedNames.last_page] === "undefined") {
+		console.warn("Remote Pagination Error - Server response missing '" + this.dataReceivedNames.last_page + "' property");
+	}
+
+	if (data[this.dataReceivedNames.data]) {
+		this.max = parseInt(data[this.dataReceivedNames.last_page]) || 1;
+
+		if (this.progressiveLoad) {
+			switch (this.mode) {
+				case "progressive_load":
+
+					if (this.page == 1) {
+						this.table.rowManager.setData(data[this.dataReceivedNames.data], false, this.initialLoad && this.page == 1);
+					} else {
+						this.table.rowManager.addRows(data[this.dataReceivedNames.data]);
+					}
+
+					if (this.page < this.max) {
+						setTimeout(function () {
+							self.nextPage().then(function () {}).catch(function () {});
+						}, self.table.options.ajaxProgressiveLoadDelay);
+					}
+					break;
+
+				case "progressive_scroll":
+					data = this.table.rowManager.getData().concat(data[this.dataReceivedNames.data]);
+
+					this.table.rowManager.setData(data, true, this.initialLoad && this.page == 1);
+
+					margin = this.table.options.ajaxProgressiveLoadScrollMargin || this.table.rowManager.element.clientHeight * 2;
+
+					if (self.table.rowManager.element.scrollHeight <= self.table.rowManager.element.clientHeight + margin) {
+						self.nextPage().then(function () {}).catch(function () {});
+					}
+					break;
+			}
+		} else {
+			left = this.table.rowManager.scrollLeft;
+
+			this.table.rowManager.setData(data[this.dataReceivedNames.data], false, this.initialLoad && this.page == 1);
+
+			this.table.rowManager.scrollHorizontal(left);
+
+			this.table.columnManager.scrollHorizontal(left);
+
+			this.table.options.pageLoaded.call(this.table, this.getPage());
+		}
+
+		this.initialLoad = false;
+	} else {
+		console.warn("Remote Pagination Error - Server response missing '" + this.dataReceivedNames.data + "' property");
+	}
+};
+
+//handle the footer element being redrawn
+Page.prototype.footerRedraw = function () {
+	var footer = this.table.footerManager.element;
+
+	if (Math.ceil(footer.clientWidth) - footer.scrollWidth < 0) {
+		this.pagesElement.style.display = 'none';
+	} else {
+		this.pagesElement.style.display = '';
+
+		if (Math.ceil(footer.clientWidth) - footer.scrollWidth < 0) {
+			this.pagesElement.style.display = 'none';
+		}
+	}
+};
+
+//set the paramter names for pagination requests
+Page.prototype.paginationDataSentNames = {
+	"page": "page",
+	"size": "size",
+	"sorters": "sorters",
+	// "sort_dir":"sort_dir",
+	"filters": "filters"
+	// "filter_value":"filter_value",
+	// "filter_type":"filter_type",
+};
+
+//set the property names for pagination responses
+Page.prototype.paginationDataReceivedNames = {
+	"current_page": "current_page",
+	"last_page": "last_page",
+	"data": "data"
+};
+
+Tabulator.prototype.registerModule("page", Page);

public/assets/vendors/tabulator/js/modules/persistence.js

@@ -0,0 +1,420 @@
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+
+var Persistence = function Persistence(table) {
+	this.table = table; //hold Tabulator object
+	this.mode = "";
+	this.id = "";
+	// this.persistProps = ["field", "width", "visible"];
+	this.defWatcherBlock = false;
+	this.config = {};
+	this.readFunc = false;
+	this.writeFunc = false;
+};
+
+// Test for whether localStorage is available for use.
+Persistence.prototype.localStorageTest = function () {
+	var testKey = "_tabulator_test";
+
+	try {
+		window.localStorage.setItem(testKey, testKey);
+		window.localStorage.removeItem(testKey);
+		return true;
+	} catch (e) {
+		return false;
+	}
+};
+
+//setup parameters
+Persistence.prototype.initialize = function () {
+	//determine persistent layout storage type
+
+	var mode = this.table.options.persistenceMode,
+	    id = this.table.options.persistenceID,
+	    retreivedData;
+
+	this.mode = mode !== true ? mode : this.localStorageTest() ? "local" : "cookie";
+
+	if (this.table.options.persistenceReaderFunc) {
+		if (typeof this.table.options.persistenceReaderFunc === "function") {
+			this.readFunc = this.table.options.persistenceReaderFunc;
+		} else {
+			if (this.readers[this.table.options.persistenceReaderFunc]) {
+				this.readFunc = this.readers[this.table.options.persistenceReaderFunc];
+			} else {
+				console.warn("Persistence Read Error - invalid reader set", this.table.options.persistenceReaderFunc);
+			}
+		}
+	} else {
+		if (this.readers[this.mode]) {
+			this.readFunc = this.readers[this.mode];
+		} else {
+			console.warn("Persistence Read Error - invalid reader set", this.mode);
+		}
+	}
+
+	if (this.table.options.persistenceWriterFunc) {
+		if (typeof this.table.options.persistenceWriterFunc === "function") {
+			this.writeFunc = this.table.options.persistenceWriterFunc;
+		} else {
+			if (this.readers[this.table.options.persistenceWriterFunc]) {
+				this.writeFunc = this.readers[this.table.options.persistenceWriterFunc];
+			} else {
+				console.warn("Persistence Write Error - invalid reader set", this.table.options.persistenceWriterFunc);
+			}
+		}
+	} else {
+		if (this.writers[this.mode]) {
+			this.writeFunc = this.writers[this.mode];
+		} else {
+			console.warn("Persistence Write Error - invalid writer set", this.mode);
+		}
+	}
+
+	//set storage tag
+	this.id = "tabulator-" + (id || this.table.element.getAttribute("id") || "");
+
+	this.config = {
+		sort: this.table.options.persistence === true || this.table.options.persistence.sort,
+		filter: this.table.options.persistence === true || this.table.options.persistence.filter,
+		group: this.table.options.persistence === true || this.table.options.persistence.group,
+		page: this.table.options.persistence === true || this.table.options.persistence.page,
+		columns: this.table.options.persistence === true ? ["title", "width", "visible"] : this.table.options.persistence.columns
+	};
+
+	//load pagination data if needed
+	if (this.config.page) {
+		retreivedData = this.retreiveData("page");
+
+		if (retreivedData) {
+			if (typeof retreivedData.paginationSize !== "undefined" && (this.config.page === true || this.config.page.size)) {
+				this.table.options.paginationSize = retreivedData.paginationSize;
+			}
+
+			if (typeof retreivedData.paginationInitialPage !== "undefined" && (this.config.page === true || this.config.page.page)) {
+				this.table.options.paginationInitialPage = retreivedData.paginationInitialPage;
+			}
+		}
+	}
+
+	//load group data if needed
+	if (this.config.group) {
+		retreivedData = this.retreiveData("group");
+
+		if (retreivedData) {
+			if (typeof retreivedData.groupBy !== "undefined" && (this.config.group === true || this.config.group.groupBy)) {
+				this.table.options.groupBy = retreivedData.groupBy;
+			}
+			if (typeof retreivedData.groupStartOpen !== "undefined" && (this.config.group === true || this.config.group.groupStartOpen)) {
+				this.table.options.groupStartOpen = retreivedData.groupStartOpen;
+			}
+			if (typeof retreivedData.groupHeader !== "undefined" && (this.config.group === true || this.config.group.groupHeader)) {
+				this.table.options.groupHeader = retreivedData.groupHeader;
+			}
+		}
+	}
+
+	if (this.config.columns) {
+		this.table.options.columns = this.load("columns", this.table.options.columns);
+	}
+};
+
+Persistence.prototype.initializeColumn = function (column) {
+	var self = this,
+	    def,
+	    keys;
+
+	if (this.config.columns) {
+		this.defWatcherBlock = true;
+
+		def = column.getDefinition();
+
+		keys = this.config.columns === true ? Object.keys(def) : this.config.columns;
+
+		keys.forEach(function (key) {
+			var props = Object.getOwnPropertyDescriptor(def, key);
+			var value = def[key];
+			if (props) {
+				Object.defineProperty(def, key, {
+					set: function set(newValue) {
+						value = newValue;
+
+						if (!self.defWatcherBlock) {
+							self.save("columns");
+						}
+
+						if (props.set) {
+							props.set(newValue);
+						}
+					},
+					get: function get() {
+						if (props.get) {
+							props.get();
+						}
+						return value;
+					}
+				});
+			}
+		});
+
+		this.defWatcherBlock = false;
+	}
+};
+
+//load saved definitions
+Persistence.prototype.load = function (type, current) {
+	var data = this.retreiveData(type);
+
+	if (current) {
+		data = data ? this.mergeDefinition(current, data) : current;
+	}
+
+	return data;
+};
+
+//retreive data from memory
+Persistence.prototype.retreiveData = function (type) {
+	return this.readFunc ? this.readFunc(this.id, type) : false;
+};
+
+//merge old and new column definitions
+Persistence.prototype.mergeDefinition = function (oldCols, newCols) {
+	var self = this,
+	    output = [];
+
+	// oldCols = oldCols || [];
+	newCols = newCols || [];
+
+	newCols.forEach(function (column, to) {
+
+		var from = self._findColumn(oldCols, column),
+		    keys;
+
+		if (from) {
+
+			if (self.config.columns === true || self.config.columns == undefined) {
+				keys = Object.keys(from);
+				keys.push("width");
+			} else {
+				keys = self.config.columns;
+			}
+
+			keys.forEach(function (key) {
+				if (key !== "columns" && typeof column[key] !== "undefined") {
+					from[key] = column[key];
+				}
+			});
+
+			if (from.columns) {
+				from.columns = self.mergeDefinition(from.columns, column.columns);
+			}
+
+			output.push(from);
+		}
+	});
+
+	oldCols.forEach(function (column, i) {
+		var from = self._findColumn(newCols, column);
+		if (!from) {
+			if (output.length > i) {
+				output.splice(i, 0, column);
+			} else {
+				output.push(column);
+			}
+		}
+	});
+
+	return output;
+};
+
+//find matching columns
+Persistence.prototype._findColumn = function (columns, subject) {
+	var type = subject.columns ? "group" : subject.field ? "field" : "object";
+
+	return columns.find(function (col) {
+		switch (type) {
+			case "group":
+				return col.title === subject.title && col.columns.length === subject.columns.length;
+				break;
+
+			case "field":
+				return col.field === subject.field;
+				break;
+
+			case "object":
+				return col === subject;
+				break;
+		}
+	});
+};
+
+//save data
+Persistence.prototype.save = function (type) {
+	var data = {};
+
+	switch (type) {
+		case "columns":
+			data = this.parseColumns(this.table.columnManager.getColumns());
+			break;
+
+		case "filter":
+			data = this.table.modules.filter.getFilters();
+			break;
+
+		case "sort":
+			data = this.validateSorters(this.table.modules.sort.getSort());
+			break;
+
+		case "group":
+			data = this.getGroupConfig();
+			break;
+
+		case "page":
+			data = this.getPageConfig();
+			break;
+	}
+
+	if (this.writeFunc) {
+		this.writeFunc(this.id, type, data);
+	}
+};
+
+//ensure sorters contain no function data
+Persistence.prototype.validateSorters = function (data) {
+	data.forEach(function (item) {
+		item.column = item.field;
+		delete item.field;
+	});
+
+	return data;
+};
+
+Persistence.prototype.getGroupConfig = function () {
+	var data = {};
+
+	if (this.config.group) {
+		if (this.config.group === true || this.config.group.groupBy) {
+			data.groupBy = this.table.options.groupBy;
+		}
+
+		if (this.config.group === true || this.config.group.groupStartOpen) {
+			data.groupStartOpen = this.table.options.groupStartOpen;
+		}
+
+		if (this.config.group === true || this.config.group.groupHeader) {
+			data.groupHeader = this.table.options.groupHeader;
+		}
+	}
+
+	return data;
+};
+
+Persistence.prototype.getPageConfig = function () {
+	var data = {};
+
+	if (this.config.page) {
+		if (this.config.page === true || this.config.page.size) {
+			data.paginationSize = this.table.modules.page.getPageSize();
+		}
+
+		if (this.config.page === true || this.config.page.page) {
+			data.paginationInitialPage = this.table.modules.page.getPage();
+		}
+	}
+
+	return data;
+};
+
+//parse columns for data to store
+Persistence.prototype.parseColumns = function (columns) {
+	var self = this,
+	    definitions = [],
+	    excludedKeys = ["headerContextMenu", "headerMenu", "contextMenu", "clickMenu"];
+
+	columns.forEach(function (column) {
+		var defStore = {},
+		    colDef = column.getDefinition(),
+		    keys;
+
+		if (column.isGroup) {
+			defStore.title = colDef.title;
+			defStore.columns = self.parseColumns(column.getColumns());
+		} else {
+			defStore.field = column.getField();
+
+			if (self.config.columns === true || self.config.columns == undefined) {
+				keys = Object.keys(colDef);
+				keys.push("width");
+			} else {
+				keys = self.config.columns;
+			}
+
+			keys.forEach(function (key) {
+
+				switch (key) {
+					case "width":
+						defStore.width = column.getWidth();
+						break;
+					case "visible":
+						defStore.visible = column.visible;
+						break;
+
+					default:
+						if (typeof colDef[key] !== "function" && excludedKeys.indexOf(key) === -1) {
+							defStore[key] = colDef[key];
+						}
+				}
+			});
+		}
+
+		definitions.push(defStore);
+	});
+
+	return definitions;
+};
+
+// read peristence information from storage
+Persistence.prototype.readers = {
+	local: function local(id, type) {
+		var data = localStorage.getItem(id + "-" + type);
+
+		return data ? JSON.parse(data) : false;
+	},
+	cookie: function cookie(id, type) {
+		var cookie = document.cookie,
+		    key = id + "-" + type,
+		    cookiePos = cookie.indexOf(key + "="),
+		    end,
+		    data;
+
+		//if cookie exists, decode and load column data into tabulator
+		if (cookiePos > -1) {
+			cookie = cookie.substr(cookiePos);
+
+			end = cookie.indexOf(";");
+
+			if (end > -1) {
+				cookie = cookie.substr(0, end);
+			}
+
+			data = cookie.replace(key + "=", "");
+		}
+
+		return data ? JSON.parse(data) : false;
+	}
+};
+
+//write persistence information to storage
+Persistence.prototype.writers = {
+	local: function local(id, type, data) {
+		localStorage.setItem(id + "-" + type, JSON.stringify(data));
+	},
+	cookie: function cookie(id, type, data) {
+		var expireDate = new Date();
+
+		expireDate.setDate(expireDate.getDate() + 10000);
+
+		document.cookie = id + "-" + type + "=" + JSON.stringify(data) + "; expires=" + expireDate.toUTCString();
+	}
+};
+
+Tabulator.prototype.registerModule("persistence", Persistence);

public/assets/vendors/tabulator/js/modules/print.js

@@ -0,0 +1,96 @@
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+
+var Print = function Print(table) {
+	this.table = table; //hold Tabulator object
+	this.element = false;
+	this.manualBlock = false;
+};
+
+Print.prototype.initialize = function () {
+	window.addEventListener("beforeprint", this.replaceTable.bind(this));
+	window.addEventListener("afterprint", this.cleanup.bind(this));
+};
+
+Print.prototype.replaceTable = function () {
+	if (!this.manualBlock) {
+		this.element = document.createElement("div");
+		this.element.classList.add("tabulator-print-table");
+
+		this.element.appendChild(this.table.modules.export.genereateTable(this.table.options.printConfig, this.table.options.printStyled, this.table.options.printRowRange, "print"));
+
+		this.table.element.style.display = "none";
+
+		this.table.element.parentNode.insertBefore(this.element, this.table.element);
+	}
+};
+
+Print.prototype.cleanup = function () {
+	document.body.classList.remove("tabulator-print-fullscreen-hide");
+
+	if (this.element && this.element.parentNode) {
+		this.element.parentNode.removeChild(this.element);
+		this.table.element.style.display = "";
+	}
+};
+
+Print.prototype.printFullscreen = function (visible, style, config) {
+	var scrollX = window.scrollX,
+	    scrollY = window.scrollY,
+	    headerEl = document.createElement("div"),
+	    footerEl = document.createElement("div"),
+	    tableEl = this.table.modules.export.genereateTable(typeof config != "undefined" ? config : this.table.options.printConfig, typeof style != "undefined" ? style : this.table.options.printStyled, visible || this.table.options.printRowRange, "print"),
+	    headerContent,
+	    footerContent;
+
+	this.manualBlock = true;
+
+	this.element = document.createElement("div");
+	this.element.classList.add("tabulator-print-fullscreen");
+
+	if (this.table.options.printHeader) {
+		headerEl.classList.add("tabulator-print-header");
+
+		headerContent = typeof this.table.options.printHeader == "function" ? this.table.options.printHeader.call(this.table) : this.table.options.printHeader;
+
+		if (typeof headerContent == "string") {
+			headerEl.innerHTML = headerContent;
+		} else {
+			headerEl.appendChild(headerContent);
+		}
+
+		this.element.appendChild(headerEl);
+	}
+
+	this.element.appendChild(tableEl);
+
+	if (this.table.options.printFooter) {
+		footerEl.classList.add("tabulator-print-footer");
+
+		footerContent = typeof this.table.options.printFooter == "function" ? this.table.options.printFooter.call(this.table) : this.table.options.printFooter;
+
+		if (typeof footerContent == "string") {
+			footerEl.innerHTML = footerContent;
+		} else {
+			footerEl.appendChild(footerContent);
+		}
+
+		this.element.appendChild(footerEl);
+	}
+
+	document.body.classList.add("tabulator-print-fullscreen-hide");
+	document.body.appendChild(this.element);
+
+	if (this.table.options.printFormatter) {
+		this.table.options.printFormatter(this.element, tableEl);
+	}
+
+	window.print();
+
+	this.cleanup();
+
+	window.scrollTo(scrollX, scrollY);
+
+	this.manualBlock = false;
+};
+
+Tabulator.prototype.registerModule("print", Print);

public/assets/vendors/tabulator/js/modules/print.min.js

@@ -0,0 +1,2 @@
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+var Print=function(t){this.table=t,this.element=!1,this.manualBlock=!1};Print.prototype.initialize=function(){window.addEventListener("beforeprint",this.replaceTable.bind(this)),window.addEventListener("afterprint",this.cleanup.bind(this))},Print.prototype.replaceTable=function(){this.manualBlock||(this.element=document.createElement("div"),this.element.classList.add("tabulator-print-table"),this.element.appendChild(this.table.modules.export.genereateTable(this.table.options.printConfig,this.table.options.printStyled,this.table.options.printRowRange,"print")),this.table.element.style.display="none",this.table.element.parentNode.insertBefore(this.element,this.table.element))},Print.prototype.cleanup=function(){document.body.classList.remove("tabulator-print-fullscreen-hide"),this.element&&this.element.parentNode&&(this.element.parentNode.removeChild(this.element),this.table.element.style.display="")},Print.prototype.printFullscreen=function(t,e,i){var n,l,o=window.scrollX,a=window.scrollY,s=document.createElement("div"),r=document.createElement("div"),p=this.table.modules.export.genereateTable(void 0!==i?i:this.table.options.printConfig,void 0!==e?e:this.table.options.printStyled,t,"print");this.manualBlock=!0,this.element=document.createElement("div"),this.element.classList.add("tabulator-print-fullscreen"),this.table.options.printHeader&&(s.classList.add("tabulator-print-header"),n="function"==typeof this.table.options.printHeader?this.table.options.printHeader.call(this.table):this.table.options.printHeader,"string"==typeof n?s.innerHTML=n:s.appendChild(n),this.element.appendChild(s)),this.element.appendChild(p),this.table.options.printFooter&&(r.classList.add("tabulator-print-footer"),l="function"==typeof this.table.options.printFooter?this.table.options.printFooter.call(this.table):this.table.options.printFooter,"string"==typeof l?r.innerHTML=l:r.appendChild(l),this.element.appendChild(r)),document.body.classList.add("tabulator-print-fullscreen-hide"),document.body.appendChild(this.element),this.table.options.printFormatter&&this.table.options.printFormatter(this.element,p),window.print(),this.cleanup(),window.scrollTo(o,a),this.manualBlock=!1},Tabulator.prototype.registerModule("print",Print);

public/assets/vendors/tabulator/js/modules/reactive_data.js

@@ -0,0 +1,323 @@
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+
+var ReactiveData = function ReactiveData(table) {
+	this.table = table; //hold Tabulator object
+	this.data = false;
+	this.blocked = false; //block reactivity while performing update
+	this.origFuncs = {}; // hold original data array functions to allow replacement after data is done with
+	this.currentVersion = 0;
+};
+
+ReactiveData.prototype.watchData = function (data) {
+	var self = this,
+	    pushFunc,
+	    version;
+
+	this.currentVersion++;
+
+	version = this.currentVersion;
+
+	self.unwatchData();
+
+	self.data = data;
+
+	//override array push function
+	self.origFuncs.push = data.push;
+
+	Object.defineProperty(self.data, "push", {
+		enumerable: false,
+		configurable: true,
+		value: function value() {
+			var args = Array.from(arguments);
+
+			if (!self.blocked && version === self.currentVersion) {
+				args.forEach(function (arg) {
+					self.table.rowManager.addRowActual(arg, false);
+				});
+			}
+
+			return self.origFuncs.push.apply(data, arguments);
+		}
+	});
+
+	//override array unshift function
+	self.origFuncs.unshift = data.unshift;
+
+	Object.defineProperty(self.data, "unshift", {
+		enumerable: false,
+		configurable: true,
+		value: function value() {
+			var args = Array.from(arguments);
+
+			if (!self.blocked && version === self.currentVersion) {
+				args.forEach(function (arg) {
+					self.table.rowManager.addRowActual(arg, true);
+				});
+			}
+
+			return self.origFuncs.unshift.apply(data, arguments);
+		}
+	});
+
+	//override array shift function
+	self.origFuncs.shift = data.shift;
+
+	Object.defineProperty(self.data, "shift", {
+		enumerable: false,
+		configurable: true,
+		value: function value() {
+			var row;
+
+			if (!self.blocked && version === self.currentVersion) {
+				if (self.data.length) {
+					row = self.table.rowManager.getRowFromDataObject(self.data[0]);
+
+					if (row) {
+						row.deleteActual();
+					}
+				}
+			}
+
+			return self.origFuncs.shift.call(data);
+		}
+	});
+
+	//override array pop function
+	self.origFuncs.pop = data.pop;
+
+	Object.defineProperty(self.data, "pop", {
+		enumerable: false,
+		configurable: true,
+		value: function value() {
+			var row;
+			if (!self.blocked && version === self.currentVersion) {
+				if (self.data.length) {
+					row = self.table.rowManager.getRowFromDataObject(self.data[self.data.length - 1]);
+
+					if (row) {
+						row.deleteActual();
+					}
+				}
+			}
+			return self.origFuncs.pop.call(data);
+		}
+	});
+
+	//override array splice function
+	self.origFuncs.splice = data.splice;
+
+	Object.defineProperty(self.data, "splice", {
+		enumerable: false,
+		configurable: true,
+		value: function value() {
+			var args = Array.from(arguments),
+			    start = args[0] < 0 ? data.length + args[0] : args[0],
+			    end = args[1],
+			    newRows = args[2] ? args.slice(2) : false,
+			    startRow;
+
+			if (!self.blocked && version === self.currentVersion) {
+
+				//add new rows
+				if (newRows) {
+					startRow = data[start] ? self.table.rowManager.getRowFromDataObject(data[start]) : false;
+
+					if (startRow) {
+						newRows.forEach(function (rowData) {
+							self.table.rowManager.addRowActual(rowData, true, startRow, true);
+						});
+					} else {
+						newRows = newRows.slice().reverse();
+
+						newRows.forEach(function (rowData) {
+							self.table.rowManager.addRowActual(rowData, true, false, true);
+						});
+					}
+				}
+
+				//delete removed rows
+				if (end !== 0) {
+					var oldRows = data.slice(start, typeof args[1] === "undefined" ? args[1] : start + end);
+
+					oldRows.forEach(function (rowData, i) {
+						var row = self.table.rowManager.getRowFromDataObject(rowData);
+
+						if (row) {
+							row.deleteActual(i !== oldRows.length - 1);
+						}
+					});
+				}
+
+				if (newRows || end !== 0) {
+					self.table.rowManager.reRenderInPosition();
+				}
+			}
+
+			return self.origFuncs.splice.apply(data, arguments);
+		}
+	});
+};
+
+ReactiveData.prototype.unwatchData = function () {
+	if (this.data !== false) {
+		for (var key in this.origFuncs) {
+			Object.defineProperty(this.data, key, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: this.origFuncs.key
+			});
+		}
+	}
+};
+
+ReactiveData.prototype.watchRow = function (row) {
+	var data = row.getData();
+
+	this.blocked = true;
+
+	for (var key in data) {
+		this.watchKey(row, data, key);
+	}
+
+	if (this.table.options.dataTree) {
+		this.watchTreeChildren(row);
+	}
+
+	this.blocked = false;
+};
+
+ReactiveData.prototype.watchTreeChildren = function (row) {
+	var self = this,
+	    childField = row.getData()[this.table.options.dataTreeChildField],
+	    origFuncs = {};
+
+	function rebuildTree() {
+		self.table.modules.dataTree.initializeRow(row);
+		self.table.modules.dataTree.layoutRow(row);
+		self.table.rowManager.refreshActiveData("tree", false, true);
+	}
+
+	if (childField) {
+
+		origFuncs.push = childField.push;
+
+		Object.defineProperty(childField, "push", {
+			enumerable: false,
+			configurable: true,
+			value: function value() {
+				var result = origFuncs.push.apply(childField, arguments);
+
+				rebuildTree();
+
+				return result;
+			}
+		});
+
+		origFuncs.unshift = childField.unshift;
+
+		Object.defineProperty(childField, "unshift", {
+			enumerable: false,
+			configurable: true,
+			value: function value() {
+				var result = origFuncs.unshift.apply(childField, arguments);
+
+				rebuildTree();
+
+				return result;
+			}
+		});
+
+		origFuncs.shift = childField.shift;
+
+		Object.defineProperty(childField, "shift", {
+			enumerable: false,
+			configurable: true,
+			value: function value() {
+				var result = origFuncs.shift.call(childField);
+
+				rebuildTree();
+
+				return result;
+			}
+		});
+
+		origFuncs.pop = childField.pop;
+
+		Object.defineProperty(childField, "pop", {
+			enumerable: false,
+			configurable: true,
+			value: function value() {
+				var result = origFuncs.pop.call(childField);
+
+				rebuildTree();
+
+				return result;
+			}
+		});
+
+		origFuncs.splice = childField.splice;
+
+		Object.defineProperty(childField, "splice", {
+			enumerable: false,
+			configurable: true,
+			value: function value() {
+				var result = origFuncs.splice.apply(childField, arguments);
+
+				rebuildTree();
+
+				return result;
+			}
+		});
+	}
+};
+
+ReactiveData.prototype.watchKey = function (row, data, key) {
+	var self = this,
+	    props = Object.getOwnPropertyDescriptor(data, key),
+	    value = data[key],
+	    version = this.currentVersion;
+
+	Object.defineProperty(data, key, {
+		set: function set(newValue) {
+			value = newValue;
+			if (!self.blocked && version === self.currentVersion) {
+				var update = {};
+				update[key] = newValue;
+				row.updateData(update);
+			}
+
+			if (props.set) {
+				props.set(newValue);
+			}
+		},
+		get: function get() {
+
+			if (props.get) {
+				props.get();
+			}
+
+			return value;
+		}
+	});
+};
+
+ReactiveData.prototype.unwatchRow = function (row) {
+	var data = row.getData();
+
+	for (var key in data) {
+		Object.defineProperty(data, key, {
+			value: data[key]
+		});
+	}
+};
+
+ReactiveData.prototype.block = function () {
+	this.blocked = true;
+};
+
+ReactiveData.prototype.unblock = function () {
+	this.blocked = false;
+};
+
+Tabulator.prototype.registerModule("reactiveData", ReactiveData);

public/assets/vendors/tabulator/js/modules/reactive_data.min.js

@@ -0,0 +1,2 @@
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+var ReactiveData=function(e){this.table=e,this.data=!1,this.blocked=!1,this.origFuncs={},this.currentVersion=0};ReactiveData.prototype.watchData=function(e){var t,a=this;this.currentVersion++,t=this.currentVersion,a.unwatchData(),a.data=e,a.origFuncs.push=e.push,Object.defineProperty(a.data,"push",{enumerable:!1,configurable:!0,value:function(){var r=Array.from(arguments);return a.blocked||t!==a.currentVersion||r.forEach(function(e){a.table.rowManager.addRowActual(e,!1)}),a.origFuncs.push.apply(e,arguments)}}),a.origFuncs.unshift=e.unshift,Object.defineProperty(a.data,"unshift",{enumerable:!1,configurable:!0,value:function(){var r=Array.from(arguments);return a.blocked||t!==a.currentVersion||r.forEach(function(e){a.table.rowManager.addRowActual(e,!0)}),a.origFuncs.unshift.apply(e,arguments)}}),a.origFuncs.shift=e.shift,Object.defineProperty(a.data,"shift",{enumerable:!1,configurable:!0,value:function(){var r;return a.blocked||t!==a.currentVersion||a.data.length&&(r=a.table.rowManager.getRowFromDataObject(a.data[0]))&&r.deleteActual(),a.origFuncs.shift.call(e)}}),a.origFuncs.pop=e.pop,Object.defineProperty(a.data,"pop",{enumerable:!1,configurable:!0,value:function(){var r;return a.blocked||t!==a.currentVersion||a.data.length&&(r=a.table.rowManager.getRowFromDataObject(a.data[a.data.length-1]))&&r.deleteActual(),a.origFuncs.pop.call(e)}}),a.origFuncs.splice=e.splice,Object.defineProperty(a.data,"splice",{enumerable:!1,configurable:!0,value:function(){var r,n=Array.from(arguments),o=n[0]<0?e.length+n[0]:n[0],i=n[1],c=!!n[2]&&n.slice(2);if(!a.blocked&&t===a.currentVersion){if(c&&(r=!!e[o]&&a.table.rowManager.getRowFromDataObject(e[o]),r?c.forEach(function(e){a.table.rowManager.addRowActual(e,!0,r,!0)}):(c=c.slice().reverse(),c.forEach(function(e){a.table.rowManager.addRowActual(e,!0,!1,!0)}))),0!==i){var u=e.slice(o,void 0===n[1]?n[1]:o+i);u.forEach(function(e,t){var r=a.table.rowManager.getRowFromDataObject(e);r&&r.deleteActual(t!==u.length-1)})}(c||0!==i)&&a.table.rowManager.reRenderInPosition()}return a.origFuncs.splice.apply(e,arguments)}})},ReactiveData.prototype.unwatchData=function(){if(!1!==this.data)for(var e in this.origFuncs)Object.defineProperty(this.data,e,{enumerable:!0,configurable:!0,writable:!0,value:this.origFuncs.key})},ReactiveData.prototype.watchRow=function(e){var t=e.getData();this.blocked=!0;for(var a in t)this.watchKey(e,t,a);this.table.options.dataTree&&this.watchTreeChildren(e),this.blocked=!1},ReactiveData.prototype.watchTreeChildren=function(e){function t(){a.table.modules.dataTree.initializeRow(e),a.table.modules.dataTree.layoutRow(e),a.table.rowManager.refreshActiveData("tree",!1,!0)}var a=this,r=e.getData()[this.table.options.dataTreeChildField],n={};r&&(n.push=r.push,Object.defineProperty(r,"push",{enumerable:!1,configurable:!0,value:function(){var e=n.push.apply(r,arguments);return t(),e}}),n.unshift=r.unshift,Object.defineProperty(r,"unshift",{enumerable:!1,configurable:!0,value:function(){var e=n.unshift.apply(r,arguments);return t(),e}}),n.shift=r.shift,Object.defineProperty(r,"shift",{enumerable:!1,configurable:!0,value:function(){var e=n.shift.call(r);return t(),e}}),n.pop=r.pop,Object.defineProperty(r,"pop",{enumerable:!1,configurable:!0,value:function(){var e=n.pop.call(r);return t(),e}}),n.splice=r.splice,Object.defineProperty(r,"splice",{enumerable:!1,configurable:!0,value:function(){var e=n.splice.apply(r,arguments);return t(),e}}))},ReactiveData.prototype.watchKey=function(e,t,a){var r=this,n=Object.getOwnPropertyDescriptor(t,a),o=t[a],i=this.currentVersion;Object.defineProperty(t,a,{set:function(t){if(o=t,!r.blocked&&i===r.currentVersion){var c={};c[a]=t,e.updateData(c)}n.set&&n.set(t)},get:function(){return n.get&&n.get(),o}})},ReactiveData.prototype.unwatchRow=function(e){var t=e.getData();for(var a in t)Object.defineProperty(t,a,{value:t[a]})},ReactiveData.prototype.block=function(){this.blocked=!0},ReactiveData.prototype.unblock=function(){this.blocked=!1},Tabulator.prototype.registerModule("reactiveData",ReactiveData);

public/assets/vendors/tabulator/js/modules/resize_columns.js

@@ -0,0 +1,171 @@
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+
+var ResizeColumns = function ResizeColumns(table) {
+	this.table = table; //hold Tabulator object
+	this.startColumn = false;
+	this.startX = false;
+	this.startWidth = false;
+	this.handle = null;
+	this.prevHandle = null;
+};
+
+ResizeColumns.prototype.initializeColumn = function (type, column, element) {
+	var self = this,
+	    variableHeight = false,
+	    mode = this.table.options.resizableColumns;
+
+	//set column resize mode
+	if (type === "header") {
+		variableHeight = column.definition.formatter == "textarea" || column.definition.variableHeight;
+		column.modules.resize = { variableHeight: variableHeight };
+	}
+
+	if (mode === true || mode == type) {
+
+		var handle = document.createElement('div');
+		handle.className = "tabulator-col-resize-handle";
+
+		var prevHandle = document.createElement('div');
+		prevHandle.className = "tabulator-col-resize-handle prev";
+
+		handle.addEventListener("click", function (e) {
+			e.stopPropagation();
+		});
+
+		var handleDown = function handleDown(e) {
+			var nearestColumn = column.getLastColumn();
+
+			if (nearestColumn && self._checkResizability(nearestColumn)) {
+				self.startColumn = column;
+				self._mouseDown(e, nearestColumn, handle);
+			}
+		};
+
+		handle.addEventListener("mousedown", handleDown);
+		handle.addEventListener("touchstart", handleDown, { passive: true });
+
+		//reszie column on  double click
+		handle.addEventListener("dblclick", function (e) {
+			var col = column.getLastColumn();
+
+			if (col && self._checkResizability(col)) {
+				e.stopPropagation();
+				col.reinitializeWidth(true);
+			}
+		});
+
+		prevHandle.addEventListener("click", function (e) {
+			e.stopPropagation();
+		});
+
+		var prevHandleDown = function prevHandleDown(e) {
+			var nearestColumn, colIndex, prevColumn;
+
+			nearestColumn = column.getFirstColumn();
+
+			if (nearestColumn) {
+				colIndex = self.table.columnManager.findColumnIndex(nearestColumn);
+				prevColumn = colIndex > 0 ? self.table.columnManager.getColumnByIndex(colIndex - 1) : false;
+
+				if (prevColumn && self._checkResizability(prevColumn)) {
+					self.startColumn = column;
+					self._mouseDown(e, prevColumn, prevHandle);
+				}
+			}
+		};
+
+		prevHandle.addEventListener("mousedown", prevHandleDown);
+		prevHandle.addEventListener("touchstart", prevHandleDown, { passive: true });
+
+		//resize column on double click
+		prevHandle.addEventListener("dblclick", function (e) {
+			var nearestColumn, colIndex, prevColumn;
+
+			nearestColumn = column.getFirstColumn();
+
+			if (nearestColumn) {
+				colIndex = self.table.columnManager.findColumnIndex(nearestColumn);
+				prevColumn = colIndex > 0 ? self.table.columnManager.getColumnByIndex(colIndex - 1) : false;
+
+				if (prevColumn && self._checkResizability(prevColumn)) {
+					e.stopPropagation();
+					prevColumn.reinitializeWidth(true);
+				}
+			}
+		});
+
+		element.appendChild(handle);
+		element.appendChild(prevHandle);
+	}
+};
+
+ResizeColumns.prototype._checkResizability = function (column) {
+	return typeof column.definition.resizable != "undefined" ? column.definition.resizable : this.table.options.resizableColumns;
+};
+
+ResizeColumns.prototype._mouseDown = function (e, column, handle) {
+	var self = this;
+
+	self.table.element.classList.add("tabulator-block-select");
+
+	function mouseMove(e) {
+		// self.table.columnManager.tempScrollBlock();
+
+		if (self.table.rtl) {
+			column.setWidth(self.startWidth - ((typeof e.screenX === "undefined" ? e.touches[0].screenX : e.screenX) - self.startX));
+		} else {
+			column.setWidth(self.startWidth + ((typeof e.screenX === "undefined" ? e.touches[0].screenX : e.screenX) - self.startX));
+		}
+
+		if (self.table.options.virtualDomHoz) {
+			self.table.vdomHoz.reinitialize(true);
+		}
+
+		if (!self.table.browserSlow && column.modules.resize && column.modules.resize.variableHeight) {
+			column.checkCellHeights();
+		}
+	}
+
+	function mouseUp(e) {
+
+		//block editor from taking action while resizing is taking place
+		if (self.startColumn.modules.edit) {
+			self.startColumn.modules.edit.blocked = false;
+		}
+
+		if (self.table.browserSlow && column.modules.resize && column.modules.resize.variableHeight) {
+			column.checkCellHeights();
+		}
+
+		document.body.removeEventListener("mouseup", mouseUp);
+		document.body.removeEventListener("mousemove", mouseMove);
+
+		handle.removeEventListener("touchmove", mouseMove);
+		handle.removeEventListener("touchend", mouseUp);
+
+		self.table.element.classList.remove("tabulator-block-select");
+
+		if (self.table.options.persistence && self.table.modExists("persistence", true) && self.table.modules.persistence.config.columns) {
+			self.table.modules.persistence.save("columns");
+		}
+
+		self.table.options.columnResized.call(self.table, column.getComponent());
+	}
+
+	e.stopPropagation(); //prevent resize from interfereing with movable columns
+
+	//block editor from taking action while resizing is taking place
+	if (self.startColumn.modules.edit) {
+		self.startColumn.modules.edit.blocked = true;
+	}
+
+	self.startX = typeof e.screenX === "undefined" ? e.touches[0].screenX : e.screenX;
+	self.startWidth = column.getWidth();
+
+	document.body.addEventListener("mousemove", mouseMove);
+	document.body.addEventListener("mouseup", mouseUp);
+	handle.addEventListener("touchmove", mouseMove, { passive: true });
+	handle.addEventListener("touchend", mouseUp);
+};
+
+Tabulator.prototype.registerModule("resizeColumns", ResizeColumns);

public/assets/vendors/tabulator/js/modules/resize_columns.min.js

@@ -0,0 +1,2 @@
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+var ResizeColumns=function(e){this.table=e,this.startColumn=!1,this.startX=!1,this.startWidth=!1,this.handle=null,this.prevHandle=null};ResizeColumns.prototype.initializeColumn=function(e,t,i){var o=this,n=!1,s=this.table.options.resizableColumns;if("header"===e&&(n="textarea"==t.definition.formatter||t.definition.variableHeight,t.modules.resize={variableHeight:n}),!0===s||s==e){var a=document.createElement("div");a.className="tabulator-col-resize-handle";var l=document.createElement("div");l.className="tabulator-col-resize-handle prev",a.addEventListener("click",function(e){e.stopPropagation()});var r=function(e){var i=t.getLastColumn();i&&o._checkResizability(i)&&(o.startColumn=t,o._mouseDown(e,i,a))};a.addEventListener("mousedown",r),a.addEventListener("touchstart",r,{passive:!0}),a.addEventListener("dblclick",function(e){var i=t.getLastColumn();i&&o._checkResizability(i)&&(e.stopPropagation(),i.reinitializeWidth(!0))}),l.addEventListener("click",function(e){e.stopPropagation()});var d=function(e){var i,n,s;(i=t.getFirstColumn())&&(n=o.table.columnManager.findColumnIndex(i),(s=n>0&&o.table.columnManager.getColumnByIndex(n-1))&&o._checkResizability(s)&&(o.startColumn=t,o._mouseDown(e,s,l)))};l.addEventListener("mousedown",d),l.addEventListener("touchstart",d,{passive:!0}),l.addEventListener("dblclick",function(e){var i,n,s;(i=t.getFirstColumn())&&(n=o.table.columnManager.findColumnIndex(i),(s=n>0&&o.table.columnManager.getColumnByIndex(n-1))&&o._checkResizability(s)&&(e.stopPropagation(),s.reinitializeWidth(!0)))}),i.appendChild(a),i.appendChild(l)}},ResizeColumns.prototype._checkResizability=function(e){return void 0!==e.definition.resizable?e.definition.resizable:this.table.options.resizableColumns},ResizeColumns.prototype._mouseDown=function(e,t,i){function o(e){s.table.rtl?t.setWidth(s.startWidth-((void 0===e.screenX?e.touches[0].screenX:e.screenX)-s.startX)):t.setWidth(s.startWidth+((void 0===e.screenX?e.touches[0].screenX:e.screenX)-s.startX)),s.table.options.virtualDomHoz&&s.table.vdomHoz.reinitialize(!0),!s.table.browserSlow&&t.modules.resize&&t.modules.resize.variableHeight&&t.checkCellHeights()}function n(e){s.startColumn.modules.edit&&(s.startColumn.modules.edit.blocked=!1),s.table.browserSlow&&t.modules.resize&&t.modules.resize.variableHeight&&t.checkCellHeights(),document.body.removeEventListener("mouseup",n),document.body.removeEventListener("mousemove",o),i.removeEventListener("touchmove",o),i.removeEventListener("touchend",n),s.table.element.classList.remove("tabulator-block-select"),s.table.options.persistence&&s.table.modExists("persistence",!0)&&s.table.modules.persistence.config.columns&&s.table.modules.persistence.save("columns"),s.table.options.columnResized.call(s.table,t.getComponent())}var s=this;s.table.element.classList.add("tabulator-block-select"),e.stopPropagation(),s.startColumn.modules.edit&&(s.startColumn.modules.edit.blocked=!0),s.startX=void 0===e.screenX?e.touches[0].screenX:e.screenX,s.startWidth=t.getWidth(),document.body.addEventListener("mousemove",o),document.body.addEventListener("mouseup",n),i.addEventListener("touchmove",o,{passive:!0}),i.addEventListener("touchend",n)},Tabulator.prototype.registerModule("resizeColumns",ResizeColumns);

public/assets/vendors/tabulator/js/modules/resize_rows.js

@@ -0,0 +1,98 @@
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+
+var ResizeRows = function ResizeRows(table) {
+	this.table = table; //hold Tabulator object
+	this.startColumn = false;
+	this.startY = false;
+	this.startHeight = false;
+	this.handle = null;
+	this.prevHandle = null;
+};
+
+ResizeRows.prototype.initializeRow = function (row) {
+	var self = this,
+	    rowEl = row.getElement();
+
+	var handle = document.createElement('div');
+	handle.className = "tabulator-row-resize-handle";
+
+	var prevHandle = document.createElement('div');
+	prevHandle.className = "tabulator-row-resize-handle prev";
+
+	handle.addEventListener("click", function (e) {
+		e.stopPropagation();
+	});
+
+	var handleDown = function handleDown(e) {
+		self.startRow = row;
+		self._mouseDown(e, row, handle);
+	};
+
+	handle.addEventListener("mousedown", handleDown);
+	handle.addEventListener("touchstart", handleDown, { passive: true });
+
+	prevHandle.addEventListener("click", function (e) {
+		e.stopPropagation();
+	});
+
+	var prevHandleDown = function prevHandleDown(e) {
+		var prevRow = self.table.rowManager.prevDisplayRow(row);
+
+		if (prevRow) {
+			self.startRow = prevRow;
+			self._mouseDown(e, prevRow, prevHandle);
+		}
+	};
+
+	prevHandle.addEventListener("mousedown", prevHandleDown);
+	prevHandle.addEventListener("touchstart", prevHandleDown, { passive: true });
+
+	rowEl.appendChild(handle);
+	rowEl.appendChild(prevHandle);
+};
+
+ResizeRows.prototype._mouseDown = function (e, row, handle) {
+	var self = this;
+
+	self.table.element.classList.add("tabulator-block-select");
+
+	function mouseMove(e) {
+		row.setHeight(self.startHeight + ((typeof e.screenY === "undefined" ? e.touches[0].screenY : e.screenY) - self.startY));
+	}
+
+	function mouseUp(e) {
+
+		// //block editor from taking action while resizing is taking place
+		// if(self.startColumn.modules.edit){
+		// 	self.startColumn.modules.edit.blocked = false;
+		// }
+
+		document.body.removeEventListener("mouseup", mouseMove);
+		document.body.removeEventListener("mousemove", mouseMove);
+
+		handle.removeEventListener("touchmove", mouseMove);
+		handle.removeEventListener("touchend", mouseUp);
+
+		self.table.element.classList.remove("tabulator-block-select");
+
+		self.table.options.rowResized.call(this.table, row.getComponent());
+	}
+
+	e.stopPropagation(); //prevent resize from interfereing with movable columns
+
+	//block editor from taking action while resizing is taking place
+	// if(self.startColumn.modules.edit){
+	// 	self.startColumn.modules.edit.blocked = true;
+	// }
+
+	self.startY = typeof e.screenY === "undefined" ? e.touches[0].screenY : e.screenY;
+	self.startHeight = row.getHeight();
+
+	document.body.addEventListener("mousemove", mouseMove);
+	document.body.addEventListener("mouseup", mouseUp);
+
+	handle.addEventListener("touchmove", mouseMove, { passive: true });
+	handle.addEventListener("touchend", mouseUp);
+};
+
+Tabulator.prototype.registerModule("resizeRows", ResizeRows);

public/assets/vendors/tabulator/js/modules/resize_rows.min.js

@@ -0,0 +1,2 @@
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+var ResizeRows=function(e){this.table=e,this.startColumn=!1,this.startY=!1,this.startHeight=!1,this.handle=null,this.prevHandle=null};ResizeRows.prototype.initializeRow=function(e){var t=this,o=e.getElement(),s=document.createElement("div");s.className="tabulator-row-resize-handle";var n=document.createElement("div");n.className="tabulator-row-resize-handle prev",s.addEventListener("click",function(e){e.stopPropagation()});var a=function(o){t.startRow=e,t._mouseDown(o,e,s)};s.addEventListener("mousedown",a),s.addEventListener("touchstart",a,{passive:!0}),n.addEventListener("click",function(e){e.stopPropagation()});var r=function(o){var s=t.table.rowManager.prevDisplayRow(e);s&&(t.startRow=s,t._mouseDown(o,s,n))};n.addEventListener("mousedown",r),n.addEventListener("touchstart",r,{passive:!0}),o.appendChild(s),o.appendChild(n)},ResizeRows.prototype._mouseDown=function(e,t,o){function s(e){t.setHeight(a.startHeight+((void 0===e.screenY?e.touches[0].screenY:e.screenY)-a.startY))}function n(e){document.body.removeEventListener("mouseup",s),document.body.removeEventListener("mousemove",s),o.removeEventListener("touchmove",s),o.removeEventListener("touchend",n),a.table.element.classList.remove("tabulator-block-select"),a.table.options.rowResized.call(this.table,t.getComponent())}var a=this;a.table.element.classList.add("tabulator-block-select"),e.stopPropagation(),a.startY=void 0===e.screenY?e.touches[0].screenY:e.screenY,a.startHeight=t.getHeight(),document.body.addEventListener("mousemove",s),document.body.addEventListener("mouseup",n),o.addEventListener("touchmove",s,{passive:!0}),o.addEventListener("touchend",n)},Tabulator.prototype.registerModule("resizeRows",ResizeRows);

public/assets/vendors/tabulator/js/modules/resize_table.js

@@ -0,0 +1,117 @@
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+
+var ResizeTable = function ResizeTable(table) {
+	this.table = table; //hold Tabulator object
+	this.binding = false;
+	this.observer = false;
+	this.containerObserver = false;
+
+	this.tableHeight = 0;
+	this.tableWidth = 0;
+	this.containerHeight = 0;
+	this.containerWidth = 0;
+
+	this.autoResize = false;
+};
+
+ResizeTable.prototype.initialize = function (row) {
+	var _this = this;
+
+	var table = this.table,
+	    tableStyle;
+
+	this.tableHeight = table.element.clientHeight;
+	this.tableWidth = table.element.clientWidth;
+
+	if (table.element.parentNode) {
+		this.containerHeight = table.element.parentNode.clientHeight;
+		this.containerWidth = table.element.parentNode.clientWidth;
+	}
+
+	if (typeof ResizeObserver !== "undefined" && table.rowManager.getRenderMode() === "virtual") {
+
+		this.autoResize = true;
+
+		this.observer = new ResizeObserver(function (entry) {
+			if (!table.browserMobile || table.browserMobile && !table.modules.edit.currentCell) {
+
+				var nodeHeight = Math.floor(entry[0].contentRect.height);
+				var nodeWidth = Math.floor(entry[0].contentRect.width);
+
+				if (_this.tableHeight != nodeHeight || _this.tableWidth != nodeWidth) {
+					_this.tableHeight = nodeHeight;
+					_this.tableWidth = nodeWidth;
+
+					if (table.element.parentNode) {
+						_this.containerHeight = table.element.parentNode.clientHeight;
+						_this.containerWidth = table.element.parentNode.clientWidth;
+					}
+
+					if (table.options.virtualDomHoz) {
+						table.vdomHoz.reinitialize(true);
+					}
+
+					table.redraw();
+				}
+			}
+		});
+
+		this.observer.observe(table.element);
+
+		tableStyle = window.getComputedStyle(table.element);
+
+		if (this.table.element.parentNode && !this.table.rowManager.fixedHeight && (tableStyle.getPropertyValue("max-height") || tableStyle.getPropertyValue("min-height"))) {
+
+			this.containerObserver = new ResizeObserver(function (entry) {
+				if (!table.browserMobile || table.browserMobile && !table.modules.edit.currentCell) {
+
+					var nodeHeight = Math.floor(entry[0].contentRect.height);
+					var nodeWidth = Math.floor(entry[0].contentRect.width);
+
+					if (_this.containerHeight != nodeHeight || _this.containerWidth != nodeWidth) {
+						_this.containerHeight = nodeHeight;
+						_this.containerWidth = nodeWidth;
+						_this.tableHeight = table.element.clientHeight;
+						_this.tableWidth = table.element.clientWidth;
+					}
+
+					if (table.options.virtualDomHoz) {
+						table.vdomHoz.reinitialize(true);
+					}
+
+					table.redraw();
+				}
+			});
+
+			this.containerObserver.observe(this.table.element.parentNode);
+		}
+	} else {
+		this.binding = function () {
+			if (!table.browserMobile || table.browserMobile && !table.modules.edit.currentCell) {
+				if (table.options.virtualDomHoz) {
+					table.vdomHoz.reinitialize(true);
+				}
+
+				table.redraw();
+			}
+		};
+
+		window.addEventListener("resize", this.binding);
+	}
+};
+
+ResizeTable.prototype.clearBindings = function (row) {
+	if (this.binding) {
+		window.removeEventListener("resize", this.binding);
+	}
+
+	if (this.observer) {
+		this.observer.unobserve(this.table.element);
+	}
+
+	if (this.containerObserver) {
+		this.containerObserver.unobserve(this.table.element.parentNode);
+	}
+};
+
+Tabulator.prototype.registerModule("resizeTable", ResizeTable);

public/assets/vendors/tabulator/js/modules/resize_table.min.js

@@ -0,0 +1,2 @@
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+var ResizeTable=function(e){this.table=e,this.binding=!1,this.observer=!1,this.containerObserver=!1,this.tableHeight=0,this.tableWidth=0,this.containerHeight=0,this.containerWidth=0,this.autoResize=!1};ResizeTable.prototype.initialize=function(e){var t,i=this,n=this.table;this.tableHeight=n.element.clientHeight,this.tableWidth=n.element.clientWidth,n.element.parentNode&&(this.containerHeight=n.element.parentNode.clientHeight,this.containerWidth=n.element.parentNode.clientWidth),"undefined"!=typeof ResizeObserver&&"virtual"===n.rowManager.getRenderMode()?(this.autoResize=!0,this.observer=new ResizeObserver(function(e){if(!n.browserMobile||n.browserMobile&&!n.modules.edit.currentCell){var t=Math.floor(e[0].contentRect.height),r=Math.floor(e[0].contentRect.width);i.tableHeight==t&&i.tableWidth==r||(i.tableHeight=t,i.tableWidth=r,n.element.parentNode&&(i.containerHeight=n.element.parentNode.clientHeight,i.containerWidth=n.element.parentNode.clientWidth),n.options.virtualDomHoz&&n.vdomHoz.reinitialize(!0),n.redraw())}}),this.observer.observe(n.element),t=window.getComputedStyle(n.element),this.table.element.parentNode&&!this.table.rowManager.fixedHeight&&(t.getPropertyValue("max-height")||t.getPropertyValue("min-height"))&&(this.containerObserver=new ResizeObserver(function(e){if(!n.browserMobile||n.browserMobile&&!n.modules.edit.currentCell){var t=Math.floor(e[0].contentRect.height),r=Math.floor(e[0].contentRect.width);i.containerHeight==t&&i.containerWidth==r||(i.containerHeight=t,i.containerWidth=r,i.tableHeight=n.element.clientHeight,i.tableWidth=n.element.clientWidth),n.options.virtualDomHoz&&n.vdomHoz.reinitialize(!0),n.redraw()}}),this.containerObserver.observe(this.table.element.parentNode))):(this.binding=function(){(!n.browserMobile||n.browserMobile&&!n.modules.edit.currentCell)&&(n.options.virtualDomHoz&&n.vdomHoz.reinitialize(!0),n.redraw())},window.addEventListener("resize",this.binding))},ResizeTable.prototype.clearBindings=function(e){this.binding&&window.removeEventListener("resize",this.binding),this.observer&&this.observer.unobserve(this.table.element),this.containerObserver&&this.containerObserver.unobserve(this.table.element.parentNode)},Tabulator.prototype.registerModule("resizeTable",ResizeTable);

public/assets/vendors/tabulator/js/modules/responsive_layout.js

@@ -0,0 +1,314 @@
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+
+var ResponsiveLayout = function ResponsiveLayout(table) {
+	this.table = table; //hold Tabulator object
+	this.columns = [];
+	this.hiddenColumns = [];
+	this.mode = "";
+	this.index = 0;
+	this.collapseFormatter = [];
+	this.collapseStartOpen = true;
+	this.collapseHandleColumn = false;
+};
+
+//generate resposive columns list
+ResponsiveLayout.prototype.initialize = function () {
+	var self = this,
+	    columns = [];
+
+	this.mode = this.table.options.responsiveLayout;
+	this.collapseFormatter = this.table.options.responsiveLayoutCollapseFormatter || this.formatCollapsedData;
+	this.collapseStartOpen = this.table.options.responsiveLayoutCollapseStartOpen;
+	this.hiddenColumns = [];
+
+	//detemine level of responsivity for each column
+	this.table.columnManager.columnsByIndex.forEach(function (column, i) {
+		if (column.modules.responsive) {
+			if (column.modules.responsive.order && column.modules.responsive.visible) {
+				column.modules.responsive.index = i;
+				columns.push(column);
+
+				if (!column.visible && self.mode === "collapse") {
+					self.hiddenColumns.push(column);
+				}
+			}
+		}
+	});
+
+	//sort list by responsivity
+	columns = columns.reverse();
+	columns = columns.sort(function (a, b) {
+		var diff = b.modules.responsive.order - a.modules.responsive.order;
+		return diff || b.modules.responsive.index - a.modules.responsive.index;
+	});
+
+	this.columns = columns;
+
+	if (this.mode === "collapse") {
+		this.generateCollapsedContent();
+	}
+
+	//assign collapse column
+	for (var _iterator = this.table.columnManager.columnsByIndex, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+		var _ref;
+
+		if (_isArray) {
+			if (_i >= _iterator.length) break;
+			_ref = _iterator[_i++];
+		} else {
+			_i = _iterator.next();
+			if (_i.done) break;
+			_ref = _i.value;
+		}
+
+		var col = _ref;
+
+		if (col.definition.formatter == "responsiveCollapse") {
+			this.collapseHandleColumn = col;
+			break;
+		}
+	}
+
+	if (this.collapseHandleColumn) {
+		if (this.hiddenColumns.length) {
+			this.collapseHandleColumn.show();
+		} else {
+			this.collapseHandleColumn.hide();
+		}
+	}
+};
+
+//define layout information
+ResponsiveLayout.prototype.initializeColumn = function (column) {
+	var def = column.getDefinition();
+
+	column.modules.responsive = { order: typeof def.responsive === "undefined" ? 1 : def.responsive, visible: def.visible === false ? false : true };
+};
+
+ResponsiveLayout.prototype.initializeRow = function (row) {
+	var el;
+
+	if (row.type !== "calc") {
+		el = document.createElement("div");
+		el.classList.add("tabulator-responsive-collapse");
+
+		row.modules.responsiveLayout = {
+			element: el,
+			open: this.collapseStartOpen
+		};
+
+		if (!this.collapseStartOpen) {
+			el.style.display = 'none';
+		}
+	}
+};
+
+ResponsiveLayout.prototype.layoutRow = function (row) {
+	var rowEl = row.getElement();
+
+	if (row.modules.responsiveLayout) {
+		rowEl.appendChild(row.modules.responsiveLayout.element);
+		this.generateCollapsedRowContent(row);
+	}
+};
+
+//update column visibility
+ResponsiveLayout.prototype.updateColumnVisibility = function (column, visible) {
+	var index;
+	if (column.modules.responsive) {
+		column.modules.responsive.visible = visible;
+		this.initialize();
+	}
+};
+
+ResponsiveLayout.prototype.hideColumn = function (column) {
+	var colCount = this.hiddenColumns.length;
+
+	column.hide(false, true);
+
+	if (this.mode === "collapse") {
+		this.hiddenColumns.unshift(column);
+		this.generateCollapsedContent();
+
+		if (this.collapseHandleColumn && !colCount) {
+			this.collapseHandleColumn.show();
+		}
+	}
+};
+
+ResponsiveLayout.prototype.showColumn = function (column) {
+	var index;
+
+	column.show(false, true);
+	//set column width to prevent calculation loops on uninitialized columns
+	column.setWidth(column.getWidth());
+
+	if (this.mode === "collapse") {
+		index = this.hiddenColumns.indexOf(column);
+
+		if (index > -1) {
+			this.hiddenColumns.splice(index, 1);
+		}
+
+		this.generateCollapsedContent();
+
+		if (this.collapseHandleColumn && !this.hiddenColumns.length) {
+			this.collapseHandleColumn.hide();
+		}
+	}
+};
+
+//redraw columns to fit space
+ResponsiveLayout.prototype.update = function () {
+	var self = this,
+	    working = true;
+
+	while (working) {
+
+		var width = self.table.modules.layout.getMode() == "fitColumns" ? self.table.columnManager.getFlexBaseWidth() : self.table.columnManager.getWidth();
+
+		var diff = (self.table.options.headerVisible ? self.table.columnManager.element.clientWidth : self.table.element.clientWidth) - width;
+
+		if (diff < 0) {
+			//table is too wide
+			var column = self.columns[self.index];
+
+			if (column) {
+				self.hideColumn(column);
+				self.index++;
+			} else {
+				working = false;
+			}
+		} else {
+
+			//table has spare space
+			var _column = self.columns[self.index - 1];
+
+			if (_column) {
+				if (diff > 0) {
+					if (diff >= _column.getWidth()) {
+						self.showColumn(_column);
+						self.index--;
+					} else {
+						working = false;
+					}
+				} else {
+					working = false;
+				}
+			} else {
+				working = false;
+			}
+		}
+
+		if (!self.table.rowManager.activeRowsCount) {
+			self.table.rowManager.renderEmptyScroll();
+		}
+	}
+};
+
+ResponsiveLayout.prototype.generateCollapsedContent = function () {
+	var self = this,
+	    rows = this.table.rowManager.getDisplayRows();
+
+	rows.forEach(function (row) {
+		self.generateCollapsedRowContent(row);
+	});
+};
+
+ResponsiveLayout.prototype.generateCollapsedRowContent = function (row) {
+	var el, contents;
+
+	if (row.modules.responsiveLayout) {
+		el = row.modules.responsiveLayout.element;
+
+		while (el.firstChild) {
+			el.removeChild(el.firstChild);
+		}contents = this.collapseFormatter(this.generateCollapsedRowData(row));
+		if (contents) {
+			el.appendChild(contents);
+		}
+	}
+};
+
+ResponsiveLayout.prototype.generateCollapsedRowData = function (row) {
+	var self = this,
+	    data = row.getData(),
+	    output = [],
+	    mockCellComponent;
+
+	this.hiddenColumns.forEach(function (column) {
+		var value = column.getFieldValue(data);
+
+		if (column.definition.title && column.field) {
+			if (column.modules.format && self.table.options.responsiveLayoutCollapseUseFormatters) {
+
+				mockCellComponent = {
+					value: false,
+					data: {},
+					getValue: function getValue() {
+						return value;
+					},
+					getData: function getData() {
+						return data;
+					},
+					getElement: function getElement() {
+						return document.createElement("div");
+					},
+					getRow: function getRow() {
+						return row.getComponent();
+					},
+					getColumn: function getColumn() {
+						return column.getComponent();
+					}
+				};
+
+				output.push({
+					field: column.field,
+					title: column.definition.title,
+					value: column.modules.format.formatter.call(self.table.modules.format, mockCellComponent, column.modules.format.params)
+				});
+			} else {
+				output.push({
+					field: column.field,
+					title: column.definition.title,
+					value: value
+				});
+			}
+		}
+	});
+
+	return output;
+};
+
+ResponsiveLayout.prototype.formatCollapsedData = function (data) {
+	var list = document.createElement("table");
+
+	data.forEach(function (item) {
+		var row = document.createElement("tr");
+		var titleData = document.createElement("td");
+		var valueData = document.createElement("td");
+		var node_content;
+
+		var titleHighlight = document.createElement("strong");
+		titleData.appendChild(titleHighlight);
+		this.table.modules.localize.bind("columns|" + item.field, function (text) {
+			titleHighlight.innerText = text || item.title;
+		});
+
+		if (item.value instanceof Node) {
+			node_content = document.createElement("div");
+			node_content.appendChild(item.value);
+			valueData.appendChild(node_content);
+		} else {
+			valueData.innerHTML = item.value;
+		}
+
+		row.appendChild(titleData);
+		row.appendChild(valueData);
+		list.appendChild(row);
+	}, this);
+
+	return Object.keys(data).length ? list : "";
+};
+
+Tabulator.prototype.registerModule("responsiveLayout", ResponsiveLayout);

public/assets/vendors/tabulator/js/modules/select_row.js

@@ -0,0 +1,417 @@
+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; };
+
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+
+var SelectRow = function SelectRow(table) {
+	this.table = table; //hold Tabulator object
+	this.selecting = false; //flag selecting in progress
+	this.lastClickedRow = false; //last clicked row
+	this.selectPrev = []; //hold previously selected element for drag drop selection
+	this.selectedRows = []; //hold selected rows
+	this.headerCheckboxElement = null; // hold header select element
+};
+
+SelectRow.prototype.clearSelectionData = function (silent) {
+	this.selecting = false;
+	this.lastClickedRow = false;
+	this.selectPrev = [];
+	this.selectedRows = [];
+
+	if (!silent) {
+		this._rowSelectionChanged();
+	}
+};
+
+SelectRow.prototype.initializeRow = function (row) {
+	var self = this,
+	    element = row.getElement();
+
+	// trigger end of row selection
+	var endSelect = function endSelect() {
+
+		setTimeout(function () {
+			self.selecting = false;
+		}, 50);
+
+		document.body.removeEventListener("mouseup", endSelect);
+	};
+
+	row.modules.select = { selected: false };
+
+	//set row selection class
+	if (self.table.options.selectableCheck.call(this.table, row.getComponent())) {
+		element.classList.add("tabulator-selectable");
+		element.classList.remove("tabulator-unselectable");
+
+		if (self.table.options.selectable && self.table.options.selectable != "highlight") {
+			if (self.table.options.selectableRangeMode === "click") {
+				element.addEventListener("click", function (e) {
+					if (e.shiftKey) {
+						self.table._clearSelection();
+						self.lastClickedRow = self.lastClickedRow || row;
+
+						var lastClickedRowIdx = self.table.rowManager.getDisplayRowIndex(self.lastClickedRow);
+						var rowIdx = self.table.rowManager.getDisplayRowIndex(row);
+
+						var fromRowIdx = lastClickedRowIdx <= rowIdx ? lastClickedRowIdx : rowIdx;
+						var toRowIdx = lastClickedRowIdx >= rowIdx ? lastClickedRowIdx : rowIdx;
+
+						var rows = self.table.rowManager.getDisplayRows().slice(0);
+						var toggledRows = rows.splice(fromRowIdx, toRowIdx - fromRowIdx + 1);
+
+						if (e.ctrlKey || e.metaKey) {
+							toggledRows.forEach(function (toggledRow) {
+								if (toggledRow !== self.lastClickedRow) {
+
+									if (self.table.options.selectable !== true && !self.isRowSelected(row)) {
+										if (self.selectedRows.length < self.table.options.selectable) {
+											self.toggleRow(toggledRow);
+										}
+									} else {
+										self.toggleRow(toggledRow);
+									}
+								}
+							});
+							self.lastClickedRow = row;
+						} else {
+							self.deselectRows(undefined, true);
+
+							if (self.table.options.selectable !== true) {
+								if (toggledRows.length > self.table.options.selectable) {
+									toggledRows = toggledRows.slice(0, self.table.options.selectable);
+								}
+							}
+
+							self.selectRows(toggledRows);
+						}
+						self.table._clearSelection();
+					} else if (e.ctrlKey || e.metaKey) {
+						self.toggleRow(row);
+						self.lastClickedRow = row;
+					} else {
+						self.deselectRows(undefined, true);
+						self.selectRows(row);
+						self.lastClickedRow = row;
+					}
+				});
+			} else {
+				element.addEventListener("click", function (e) {
+					if (!self.table.modExists("edit") || !self.table.modules.edit.getCurrentCell()) {
+						self.table._clearSelection();
+					}
+
+					if (!self.selecting) {
+						self.toggleRow(row);
+					}
+				});
+
+				element.addEventListener("mousedown", function (e) {
+					if (e.shiftKey) {
+						self.table._clearSelection();
+
+						self.selecting = true;
+
+						self.selectPrev = [];
+
+						document.body.addEventListener("mouseup", endSelect);
+						document.body.addEventListener("keyup", endSelect);
+
+						self.toggleRow(row);
+
+						return false;
+					}
+				});
+
+				element.addEventListener("mouseenter", function (e) {
+					if (self.selecting) {
+						self.table._clearSelection();
+						self.toggleRow(row);
+
+						if (self.selectPrev[1] == row) {
+							self.toggleRow(self.selectPrev[0]);
+						}
+					}
+				});
+
+				element.addEventListener("mouseout", function (e) {
+					if (self.selecting) {
+						self.table._clearSelection();
+						self.selectPrev.unshift(row);
+					}
+				});
+			}
+		}
+	} else {
+		element.classList.add("tabulator-unselectable");
+		element.classList.remove("tabulator-selectable");
+	}
+};
+
+//toggle row selection
+SelectRow.prototype.toggleRow = function (row) {
+	if (this.table.options.selectableCheck.call(this.table, row.getComponent())) {
+		if (row.modules.select && row.modules.select.selected) {
+			this._deselectRow(row);
+		} else {
+			this._selectRow(row);
+		}
+	}
+};
+
+//select a number of rows
+SelectRow.prototype.selectRows = function (rows) {
+	var _this = this;
+
+	var rowMatch;
+
+	switch (typeof rows === "undefined" ? "undefined" : _typeof(rows)) {
+		case "undefined":
+			this.table.rowManager.rows.forEach(function (row) {
+				_this._selectRow(row, true, true);
+			});
+
+			this._rowSelectionChanged();
+			break;
+
+		case "string":
+
+			rowMatch = this.table.rowManager.findRow(rows);
+
+			if (rowMatch) {
+				this._selectRow(rowMatch, true, true);
+			} else {
+				this.table.rowManager.getRows(rows).forEach(function (row) {
+					_this._selectRow(row, true, true);
+				});
+			}
+
+			this._rowSelectionChanged();
+			break;
+
+		default:
+			if (Array.isArray(rows)) {
+				rows.forEach(function (row) {
+					_this._selectRow(row, true, true);
+				});
+
+				this._rowSelectionChanged();
+			} else {
+				this._selectRow(rows, false, true);
+			}
+			break;
+	}
+};
+
+//select an individual row
+SelectRow.prototype._selectRow = function (rowInfo, silent, force) {
+	var index;
+
+	//handle max row count
+	if (!isNaN(this.table.options.selectable) && this.table.options.selectable !== true && !force) {
+		if (this.selectedRows.length >= this.table.options.selectable) {
+			if (this.table.options.selectableRollingSelection) {
+				this._deselectRow(this.selectedRows[0]);
+			} else {
+				return false;
+			}
+		}
+	}
+
+	var row = this.table.rowManager.findRow(rowInfo);
+
+	if (row) {
+		if (this.selectedRows.indexOf(row) == -1) {
+			row.getElement().classList.add("tabulator-selected");
+			if (!row.modules.select) {
+				row.modules.select = {};
+			}
+
+			row.modules.select.selected = true;
+			if (row.modules.select.checkboxEl) {
+				row.modules.select.checkboxEl.checked = true;
+			}
+
+			this.selectedRows.push(row);
+
+			if (this.table.options.dataTreeSelectPropagate) {
+				this.childRowSelection(row, true);
+			}
+
+			if (!silent) {
+				this.table.options.rowSelected.call(this.table, row.getComponent());
+			}
+
+			this._rowSelectionChanged(silent);
+		}
+	} else {
+		if (!silent) {
+			console.warn("Selection Error - No such row found, ignoring selection:" + rowInfo);
+		}
+	}
+};
+
+SelectRow.prototype.isRowSelected = function (row) {
+	return this.selectedRows.indexOf(row) !== -1;
+};
+
+//deselect a number of rows
+SelectRow.prototype.deselectRows = function (rows, silent) {
+	var self = this,
+	    rowCount;
+
+	if (typeof rows == "undefined") {
+
+		rowCount = self.selectedRows.length;
+
+		for (var i = 0; i < rowCount; i++) {
+			self._deselectRow(self.selectedRows[0], true);
+		}
+
+		self._rowSelectionChanged(silent);
+	} else {
+		if (Array.isArray(rows)) {
+			rows.forEach(function (row) {
+				self._deselectRow(row, true);
+			});
+
+			self._rowSelectionChanged(silent);
+		} else {
+			self._deselectRow(rows, silent);
+		}
+	}
+};
+
+//deselect an individual row
+SelectRow.prototype._deselectRow = function (rowInfo, silent) {
+	var self = this,
+	    row = self.table.rowManager.findRow(rowInfo),
+	    index;
+
+	if (row) {
+		index = self.selectedRows.findIndex(function (selectedRow) {
+			return selectedRow == row;
+		});
+
+		if (index > -1) {
+
+			row.getElement().classList.remove("tabulator-selected");
+			if (!row.modules.select) {
+				row.modules.select = {};
+			}
+
+			row.modules.select.selected = false;
+			if (row.modules.select.checkboxEl) {
+				row.modules.select.checkboxEl.checked = false;
+			}
+			self.selectedRows.splice(index, 1);
+
+			if (this.table.options.dataTreeSelectPropagate) {
+				this.childRowSelection(row, false);
+			}
+
+			if (!silent) {
+				self.table.options.rowDeselected.call(this.table, row.getComponent());
+			}
+
+			self._rowSelectionChanged(silent);
+		}
+	} else {
+		if (!silent) {
+			console.warn("Deselection Error - No such row found, ignoring selection:" + rowInfo);
+		}
+	}
+};
+
+SelectRow.prototype.getSelectedData = function () {
+	var data = [];
+
+	this.selectedRows.forEach(function (row) {
+		data.push(row.getData());
+	});
+
+	return data;
+};
+
+SelectRow.prototype.getSelectedRows = function () {
+
+	var rows = [];
+
+	this.selectedRows.forEach(function (row) {
+		rows.push(row.getComponent());
+	});
+
+	return rows;
+};
+
+SelectRow.prototype._rowSelectionChanged = function (silent) {
+	if (this.headerCheckboxElement) {
+		if (this.selectedRows.length === 0) {
+			this.headerCheckboxElement.checked = false;
+			this.headerCheckboxElement.indeterminate = false;
+		} else if (this.table.rowManager.rows.length === this.selectedRows.length) {
+			this.headerCheckboxElement.checked = true;
+			this.headerCheckboxElement.indeterminate = false;
+		} else {
+			this.headerCheckboxElement.indeterminate = true;
+			this.headerCheckboxElement.checked = false;
+		}
+	}
+
+	if (!silent) {
+		this.table.options.rowSelectionChanged.call(this.table, this.getSelectedData(), this.getSelectedRows());
+	}
+};
+
+SelectRow.prototype.registerRowSelectCheckbox = function (row, element) {
+	if (!row._row.modules.select) {
+		row._row.modules.select = {};
+	}
+
+	row._row.modules.select.checkboxEl = element;
+};
+
+SelectRow.prototype.registerHeaderSelectCheckbox = function (element) {
+	this.headerCheckboxElement = element;
+};
+
+SelectRow.prototype.childRowSelection = function (row, select) {
+	var children = this.table.modules.dataTree.getChildren(row, true);
+
+	if (select) {
+		for (var _iterator = children, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+			var _ref;
+
+			if (_isArray) {
+				if (_i >= _iterator.length) break;
+				_ref = _iterator[_i++];
+			} else {
+				_i = _iterator.next();
+				if (_i.done) break;
+				_ref = _i.value;
+			}
+
+			var child = _ref;
+
+			this._selectRow(child, true);
+		}
+	} else {
+		for (var _iterator2 = children, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+			var _ref2;
+
+			if (_isArray2) {
+				if (_i2 >= _iterator2.length) break;
+				_ref2 = _iterator2[_i2++];
+			} else {
+				_i2 = _iterator2.next();
+				if (_i2.done) break;
+				_ref2 = _i2.value;
+			}
+
+			var _child = _ref2;
+
+			this._deselectRow(_child, true);
+		}
+	}
+};
+
+Tabulator.prototype.registerModule("selectRow", SelectRow);

public/assets/vendors/tabulator/js/modules/sort.js

@@ -0,0 +1,593 @@
+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; };
+
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+
+var Sort = function Sort(table) {
+	this.table = table; //hold Tabulator object
+	this.sortList = []; //holder current sort
+	this.changed = false; //has the sort changed since last render
+};
+
+//initialize column header for sorting
+Sort.prototype.initializeColumn = function (column, content) {
+	var self = this,
+	    sorter = false,
+	    colEl,
+	    arrowEl;
+
+	switch (_typeof(column.definition.sorter)) {
+		case "string":
+			if (self.sorters[column.definition.sorter]) {
+				sorter = self.sorters[column.definition.sorter];
+			} else {
+				console.warn("Sort Error - No such sorter found: ", column.definition.sorter);
+			}
+			break;
+
+		case "function":
+			sorter = column.definition.sorter;
+			break;
+	}
+
+	column.modules.sort = {
+		sorter: sorter, dir: "none",
+		params: column.definition.sorterParams || {},
+		startingDir: column.definition.headerSortStartingDir || "asc",
+		tristate: typeof column.definition.headerSortTristate !== "undefined" ? column.definition.headerSortTristate : this.table.options.headerSortTristate
+	};
+
+	if (typeof column.definition.headerSort === "undefined" ? this.table.options.headerSort !== false : column.definition.headerSort !== false) {
+
+		colEl = column.getElement();
+
+		colEl.classList.add("tabulator-sortable");
+
+		arrowEl = document.createElement("div");
+		arrowEl.classList.add("tabulator-col-sorter");
+
+		if (_typeof(this.table.options.headerSortElement) == "object") {
+			arrowEl.appendChild(this.table.options.headerSortElement);
+		} else {
+			arrowEl.innerHTML = this.table.options.headerSortElement;
+		}
+
+		//create sorter arrow
+		content.appendChild(arrowEl);
+
+		column.modules.sort.element = arrowEl;
+
+		//sort on click
+		colEl.addEventListener("click", function (e) {
+			var dir = "",
+			    sorters = [],
+			    match = false;
+
+			if (column.modules.sort) {
+				if (column.modules.sort.tristate) {
+					if (column.modules.sort.dir == "none") {
+						dir = column.modules.sort.startingDir;
+					} else {
+						if (column.modules.sort.dir == column.modules.sort.startingDir) {
+							dir = column.modules.sort.dir == "asc" ? "desc" : "asc";
+						} else {
+							dir = "none";
+						}
+					}
+				} else {
+					switch (column.modules.sort.dir) {
+						case "asc":
+							dir = "desc";
+							break;
+
+						case "desc":
+							dir = "asc";
+							break;
+
+						default:
+							dir = column.modules.sort.startingDir;
+					}
+				}
+
+				if (self.table.options.columnHeaderSortMulti && (e.shiftKey || e.ctrlKey)) {
+					sorters = self.getSort();
+
+					match = sorters.findIndex(function (sorter) {
+						return sorter.field === column.getField();
+					});
+
+					if (match > -1) {
+						sorters[match].dir = dir;
+
+						if (match != sorters.length - 1) {
+							match = sorters.splice(match, 1)[0];
+							if (dir != "none") {
+								sorters.push(match);
+							}
+						}
+					} else {
+						if (dir != "none") {
+							sorters.push({ column: column, dir: dir });
+						}
+					}
+
+					//add to existing sort
+					self.setSort(sorters);
+				} else {
+					if (dir == "none") {
+						self.clear();
+					} else {
+						//sort by column only
+						self.setSort(column, dir);
+					}
+				}
+
+				self.table.rowManager.sorterRefresh(!self.sortList.length);
+			}
+		});
+	}
+};
+
+//check if the sorters have changed since last use
+Sort.prototype.hasChanged = function () {
+	var changed = this.changed;
+	this.changed = false;
+	return changed;
+};
+
+//return current sorters
+Sort.prototype.getSort = function () {
+	var self = this,
+	    sorters = [];
+
+	self.sortList.forEach(function (item) {
+		if (item.column) {
+			sorters.push({ column: item.column.getComponent(), field: item.column.getField(), dir: item.dir });
+		}
+	});
+
+	return sorters;
+};
+
+//change sort list and trigger sort
+Sort.prototype.setSort = function (sortList, dir) {
+	var self = this,
+	    newSortList = [];
+
+	if (!Array.isArray(sortList)) {
+		sortList = [{ column: sortList, dir: dir }];
+	}
+
+	sortList.forEach(function (item) {
+		var column;
+
+		column = self.table.columnManager.findColumn(item.column);
+
+		if (column) {
+			item.column = column;
+			newSortList.push(item);
+			self.changed = true;
+		} else {
+			console.warn("Sort Warning - Sort field does not exist and is being ignored: ", item.column);
+		}
+	});
+
+	self.sortList = newSortList;
+
+	if (this.table.options.persistence && this.table.modExists("persistence", true) && this.table.modules.persistence.config.sort) {
+		this.table.modules.persistence.save("sort");
+	}
+};
+
+//clear sorters
+Sort.prototype.clear = function () {
+	this.setSort([]);
+};
+
+//find appropriate sorter for column
+Sort.prototype.findSorter = function (column) {
+	var row = this.table.rowManager.activeRows[0],
+	    sorter = "string",
+	    field,
+	    value;
+
+	if (row) {
+		row = row.getData();
+		field = column.getField();
+
+		if (field) {
+
+			value = column.getFieldValue(row);
+
+			switch (typeof value === "undefined" ? "undefined" : _typeof(value)) {
+				case "undefined":
+					sorter = "string";
+					break;
+
+				case "boolean":
+					sorter = "boolean";
+					break;
+
+				default:
+					if (!isNaN(value) && value !== "") {
+						sorter = "number";
+					} else {
+						if (value.match(/((^[0-9]+[a-z]+)|(^[a-z]+[0-9]+))+$/i)) {
+							sorter = "alphanum";
+						}
+					}
+					break;
+			}
+		}
+	}
+
+	return this.sorters[sorter];
+};
+
+//work through sort list sorting data
+Sort.prototype.sort = function (data) {
+	var self = this,
+	    sortList = this.table.options.sortOrderReverse ? self.sortList.slice().reverse() : self.sortList,
+	    sortListActual = [],
+	    rowComponents = [],
+	    lastSort;
+
+	if (self.table.options.dataSorting) {
+		self.table.options.dataSorting.call(self.table, self.getSort());
+	}
+
+	self.clearColumnHeaders();
+
+	if (!self.table.options.ajaxSorting) {
+
+		//build list of valid sorters and trigger column specific callbacks before sort begins
+		sortList.forEach(function (item, i) {
+			var sortObj = item.column.modules.sort;
+
+			if (item.column && sortObj) {
+
+				//if no sorter has been defined, take a guess
+				if (!sortObj.sorter) {
+					sortObj.sorter = self.findSorter(item.column);
+				}
+
+				item.params = typeof sortObj.params === "function" ? sortObj.params(item.column.getComponent(), item.dir) : sortObj.params;
+
+				sortListActual.push(item);
+			}
+
+			self.setColumnHeader(item.column, item.dir);
+		});
+
+		//sort data
+		if (sortListActual.length) {
+			self._sortItems(data, sortListActual);
+		}
+	} else {
+		sortList.forEach(function (item, i) {
+			self.setColumnHeader(item.column, item.dir);
+		});
+	}
+
+	if (self.table.options.dataSorted) {
+		data.forEach(function (row) {
+			rowComponents.push(row.getComponent());
+		});
+
+		self.table.options.dataSorted.call(self.table, self.getSort(), rowComponents);
+	}
+};
+
+//clear sort arrows on columns
+Sort.prototype.clearColumnHeaders = function () {
+	this.table.columnManager.getRealColumns().forEach(function (column) {
+		if (column.modules.sort) {
+			column.modules.sort.dir = "none";
+			column.getElement().setAttribute("aria-sort", "none");
+		}
+	});
+};
+
+//set the column header sort direction
+Sort.prototype.setColumnHeader = function (column, dir) {
+	column.modules.sort.dir = dir;
+	column.getElement().setAttribute("aria-sort", dir);
+};
+
+//sort each item in sort list
+Sort.prototype._sortItems = function (data, sortList) {
+	var _this = this;
+
+	var sorterCount = sortList.length - 1;
+
+	data.sort(function (a, b) {
+		var result;
+
+		for (var i = sorterCount; i >= 0; i--) {
+			var sortItem = sortList[i];
+
+			result = _this._sortRow(a, b, sortItem.column, sortItem.dir, sortItem.params);
+
+			if (result !== 0) {
+				break;
+			}
+		}
+
+		return result;
+	});
+};
+
+//process individual rows for a sort function on active data
+Sort.prototype._sortRow = function (a, b, column, dir, params) {
+	var el1Comp, el2Comp, colComp;
+
+	//switch elements depending on search direction
+	var el1 = dir == "asc" ? a : b;
+	var el2 = dir == "asc" ? b : a;
+
+	a = column.getFieldValue(el1.getData());
+	b = column.getFieldValue(el2.getData());
+
+	a = typeof a !== "undefined" ? a : "";
+	b = typeof b !== "undefined" ? b : "";
+
+	el1Comp = el1.getComponent();
+	el2Comp = el2.getComponent();
+
+	return column.modules.sort.sorter.call(this, a, b, el1Comp, el2Comp, column.getComponent(), dir, params);
+};
+
+//default data sorters
+Sort.prototype.sorters = {
+
+	//sort numbers
+	number: function number(a, b, aRow, bRow, column, dir, params) {
+		var alignEmptyValues = params.alignEmptyValues;
+		var decimal = params.decimalSeparator;
+		var thousand = params.thousandSeparator;
+		var emptyAlign = 0;
+
+		a = String(a);
+		b = String(b);
+
+		if (thousand) {
+			a = a.split(thousand).join("");
+			b = b.split(thousand).join("");
+		}
+
+		if (decimal) {
+			a = a.split(decimal).join(".");
+			b = b.split(decimal).join(".");
+		}
+
+		a = parseFloat(a);
+		b = parseFloat(b);
+
+		//handle non numeric values
+		if (isNaN(a)) {
+			emptyAlign = isNaN(b) ? 0 : -1;
+		} else if (isNaN(b)) {
+			emptyAlign = 1;
+		} else {
+			//compare valid values
+			return a - b;
+		}
+
+		//fix empty values in position
+		if (alignEmptyValues === "top" && dir === "desc" || alignEmptyValues === "bottom" && dir === "asc") {
+			emptyAlign *= -1;
+		}
+
+		return emptyAlign;
+	},
+
+	//sort strings
+	string: function string(a, b, aRow, bRow, column, dir, params) {
+		var alignEmptyValues = params.alignEmptyValues;
+		var emptyAlign = 0;
+		var locale;
+
+		//handle empty values
+		if (!a) {
+			emptyAlign = !b ? 0 : -1;
+		} else if (!b) {
+			emptyAlign = 1;
+		} else {
+			//compare valid values
+			switch (_typeof(params.locale)) {
+				case "boolean":
+					if (params.locale) {
+						locale = this.table.modules.localize.getLocale();
+					}
+					break;
+				case "string":
+					locale = params.locale;
+					break;
+			}
+
+			return String(a).toLowerCase().localeCompare(String(b).toLowerCase(), locale);
+		}
+
+		//fix empty values in position
+		if (alignEmptyValues === "top" && dir === "desc" || alignEmptyValues === "bottom" && dir === "asc") {
+			emptyAlign *= -1;
+		}
+
+		return emptyAlign;
+	},
+
+	//sort date
+	date: function date(a, b, aRow, bRow, column, dir, params) {
+		if (!params.format) {
+			params.format = "DD/MM/YYYY";
+		}
+
+		return this.sorters.datetime.call(this, a, b, aRow, bRow, column, dir, params);
+	},
+
+	//sort HH:mm formatted times
+	time: function time(a, b, aRow, bRow, column, dir, params) {
+		if (!params.format) {
+			params.format = "HH:mm";
+		}
+
+		return this.sorters.datetime.call(this, a, b, aRow, bRow, column, dir, params);
+	},
+
+	//sort datetime
+	datetime: function datetime(a, b, aRow, bRow, column, dir, params) {
+		var format = params.format || "DD/MM/YYYY HH:mm:ss",
+		    alignEmptyValues = params.alignEmptyValues,
+		    emptyAlign = 0;
+
+		if (typeof moment != "undefined") {
+			a = moment(a, format);
+			b = moment(b, format);
+
+			if (!a.isValid()) {
+				emptyAlign = !b.isValid() ? 0 : -1;
+			} else if (!b.isValid()) {
+				emptyAlign = 1;
+			} else {
+				//compare valid values
+				return a - b;
+			}
+
+			//fix empty values in position
+			if (alignEmptyValues === "top" && dir === "desc" || alignEmptyValues === "bottom" && dir === "asc") {
+				emptyAlign *= -1;
+			}
+
+			return emptyAlign;
+		} else {
+			console.error("Sort Error - 'datetime' sorter is dependant on moment.js");
+		}
+	},
+
+	//sort booleans
+	boolean: function boolean(a, b, aRow, bRow, column, dir, params) {
+		var el1 = a === true || a === "true" || a === "True" || a === 1 ? 1 : 0;
+		var el2 = b === true || b === "true" || b === "True" || b === 1 ? 1 : 0;
+
+		return el1 - el2;
+	},
+
+	//sort if element contains any data
+	array: function array(a, b, aRow, bRow, column, dir, params) {
+		var el1 = 0;
+		var el2 = 0;
+		var type = params.type || "length";
+		var alignEmptyValues = params.alignEmptyValues;
+		var emptyAlign = 0;
+
+		function calc(value) {
+
+			switch (type) {
+				case "length":
+					return value.length;
+					break;
+
+				case "sum":
+					return value.reduce(function (c, d) {
+						return c + d;
+					});
+					break;
+
+				case "max":
+					return Math.max.apply(null, value);
+					break;
+
+				case "min":
+					return Math.min.apply(null, value);
+					break;
+
+				case "avg":
+					return value.reduce(function (c, d) {
+						return c + d;
+					}) / value.length;
+					break;
+			}
+		}
+
+		//handle non array values
+		if (!Array.isArray(a)) {
+			alignEmptyValues = !Array.isArray(b) ? 0 : -1;
+		} else if (!Array.isArray(b)) {
+			alignEmptyValues = 1;
+		} else {
+
+			//compare valid values
+			el1 = a ? calc(a) : 0;
+			el2 = b ? calc(b) : 0;
+
+			return el1 - el2;
+		}
+
+		//fix empty values in position
+		if (alignEmptyValues === "top" && dir === "desc" || alignEmptyValues === "bottom" && dir === "asc") {
+			emptyAlign *= -1;
+		}
+
+		return emptyAlign;
+	},
+
+	//sort if element contains any data
+	exists: function exists(a, b, aRow, bRow, column, dir, params) {
+		var el1 = typeof a == "undefined" ? 0 : 1;
+		var el2 = typeof b == "undefined" ? 0 : 1;
+
+		return el1 - el2;
+	},
+
+	//sort alpha numeric strings
+	alphanum: function alphanum(as, bs, aRow, bRow, column, dir, params) {
+		var a,
+		    b,
+		    a1,
+		    b1,
+		    i = 0,
+		    L,
+		    rx = /(\d+)|(\D+)/g,
+		    rd = /\d/;
+		var alignEmptyValues = params.alignEmptyValues;
+		var emptyAlign = 0;
+
+		//handle empty values
+		if (!as && as !== 0) {
+			emptyAlign = !bs && bs !== 0 ? 0 : -1;
+		} else if (!bs && bs !== 0) {
+			emptyAlign = 1;
+		} else {
+
+			if (isFinite(as) && isFinite(bs)) return as - bs;
+			a = String(as).toLowerCase();
+			b = String(bs).toLowerCase();
+			if (a === b) return 0;
+			if (!(rd.test(a) && rd.test(b))) return a > b ? 1 : -1;
+			a = a.match(rx);
+			b = b.match(rx);
+			L = a.length > b.length ? b.length : a.length;
+			while (i < L) {
+				a1 = a[i];
+				b1 = b[i++];
+				if (a1 !== b1) {
+					if (isFinite(a1) && isFinite(b1)) {
+						if (a1.charAt(0) === "0") a1 = "." + a1;
+						if (b1.charAt(0) === "0") b1 = "." + b1;
+						return a1 - b1;
+					} else return a1 > b1 ? 1 : -1;
+				}
+			}
+
+			return a.length > b.length;
+		}
+
+		//fix empty values in position
+		if (alignEmptyValues === "top" && dir === "desc" || alignEmptyValues === "bottom" && dir === "asc") {
+			emptyAlign *= -1;
+		}
+
+		return emptyAlign;
+	}
+};
+
+Tabulator.prototype.registerModule("sort", Sort);

public/assets/vendors/tabulator/js/modules/validate.js

@@ -0,0 +1,286 @@
+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; };
+
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+
+var Validate = function Validate(table) {
+	this.table = table;
+	this.invalidCells = [];
+};
+
+//validate
+Validate.prototype.initializeColumn = function (column) {
+	var self = this,
+	    config = [],
+	    validator;
+
+	if (column.definition.validator) {
+
+		if (Array.isArray(column.definition.validator)) {
+			column.definition.validator.forEach(function (item) {
+				validator = self._extractValidator(item);
+
+				if (validator) {
+					config.push(validator);
+				}
+			});
+		} else {
+			validator = this._extractValidator(column.definition.validator);
+
+			if (validator) {
+				config.push(validator);
+			}
+		}
+
+		column.modules.validate = config.length ? config : false;
+	}
+};
+
+Validate.prototype._extractValidator = function (value) {
+	var type, params, pos;
+
+	switch (typeof value === "undefined" ? "undefined" : _typeof(value)) {
+		case "string":
+			pos = value.indexOf(':');
+
+			if (pos > -1) {
+				type = value.substring(0, pos);
+				params = value.substring(pos + 1);
+			} else {
+				type = value;
+			}
+
+			return this._buildValidator(type, params);
+			break;
+
+		case "function":
+			return this._buildValidator(value);
+			break;
+
+		case "object":
+			return this._buildValidator(value.type, value.parameters);
+			break;
+	}
+};
+
+Validate.prototype._buildValidator = function (type, params) {
+
+	var func = typeof type == "function" ? type : this.validators[type];
+
+	if (!func) {
+		console.warn("Validator Setup Error - No matching validator found:", type);
+		return false;
+	} else {
+		return {
+			type: typeof type == "function" ? "function" : type,
+			func: func,
+			params: params
+		};
+	}
+};
+
+Validate.prototype.validate = function (validators, cell, value) {
+	var self = this,
+	    valid = [],
+	    invalidIndex = this.invalidCells.indexOf(cell);
+
+	if (validators) {
+		validators.forEach(function (item) {
+			if (!item.func.call(self, cell.getComponent(), value, item.params)) {
+				valid.push({
+					type: item.type,
+					parameters: item.params
+				});
+			}
+		});
+	}
+
+	valid = valid.length ? valid : true;
+
+	if (!cell.modules.validate) {
+		cell.modules.validate = {};
+	}
+
+	if (valid === true) {
+		cell.modules.validate.invalid = false;
+		cell.getElement().classList.remove("tabulator-validation-fail");
+
+		if (invalidIndex > -1) {
+			this.invalidCells.splice(invalidIndex, 1);
+		}
+	} else {
+		cell.modules.validate.invalid = true;
+
+		if (this.table.options.validationMode !== "manual") {
+			cell.getElement().classList.add("tabulator-validation-fail");
+		}
+
+		if (invalidIndex == -1) {
+			this.invalidCells.push(cell);
+		}
+	}
+
+	return valid;
+};
+
+Validate.prototype.getInvalidCells = function () {
+	var output = [];
+
+	this.invalidCells.forEach(function (cell) {
+		output.push(cell.getComponent());
+	});
+
+	return output;
+};
+
+Validate.prototype.clearValidation = function (cell) {
+	var invalidIndex;
+
+	if (cell.modules.validate && cell.modules.validate.invalid) {
+
+		cell.getElement().classList.remove("tabulator-validation-fail");
+		cell.modules.validate.invalid = false;
+
+		invalidIndex = this.invalidCells.indexOf(cell);
+
+		if (invalidIndex > -1) {
+			this.invalidCells.splice(invalidIndex, 1);
+		}
+	}
+};
+
+Validate.prototype.validators = {
+
+	//is integer
+	integer: function integer(cell, value, parameters) {
+		if (value === "" || value === null || typeof value === "undefined") {
+			return true;
+		}
+		value = Number(value);
+		return typeof value === 'number' && isFinite(value) && Math.floor(value) === value;
+	},
+
+	//is float
+	float: function float(cell, value, parameters) {
+		if (value === "" || value === null || typeof value === "undefined") {
+			return true;
+		}
+		value = Number(value);
+		return typeof value === 'number' && isFinite(value) && value % 1 !== 0;
+	},
+
+	//must be a number
+	numeric: function numeric(cell, value, parameters) {
+		if (value === "" || value === null || typeof value === "undefined") {
+			return true;
+		}
+		return !isNaN(value);
+	},
+
+	//must be a string
+	string: function string(cell, value, parameters) {
+		if (value === "" || value === null || typeof value === "undefined") {
+			return true;
+		}
+		return isNaN(value);
+	},
+
+	//maximum value
+	max: function max(cell, value, parameters) {
+		if (value === "" || value === null || typeof value === "undefined") {
+			return true;
+		}
+		return parseFloat(value) <= parameters;
+	},
+
+	//minimum value
+	min: function min(cell, value, parameters) {
+		if (value === "" || value === null || typeof value === "undefined") {
+			return true;
+		}
+		return parseFloat(value) >= parameters;
+	},
+
+	//starts with  value
+	starts: function starts(cell, value, parameters) {
+		if (value === "" || value === null || typeof value === "undefined") {
+			return true;
+		}
+		return String(value).toLowerCase().startsWith(String(parameters).toLowerCase());
+	},
+
+	//ends with  value
+	ends: function ends(cell, value, parameters) {
+		if (value === "" || value === null || typeof value === "undefined") {
+			return true;
+		}
+		return String(value).toLowerCase().endsWith(String(parameters).toLowerCase());
+	},
+
+	//minimum string length
+	minLength: function minLength(cell, value, parameters) {
+		if (value === "" || value === null || typeof value === "undefined") {
+			return true;
+		}
+		return String(value).length >= parameters;
+	},
+
+	//maximum string length
+	maxLength: function maxLength(cell, value, parameters) {
+		if (value === "" || value === null || typeof value === "undefined") {
+			return true;
+		}
+		return String(value).length <= parameters;
+	},
+
+	//in provided value list
+	in: function _in(cell, value, parameters) {
+		if (value === "" || value === null || typeof value === "undefined") {
+			return true;
+		}
+		if (typeof parameters == "string") {
+			parameters = parameters.split("|");
+		}
+
+		return value === "" || parameters.indexOf(value) > -1;
+	},
+
+	//must match provided regex
+	regex: function regex(cell, value, parameters) {
+		if (value === "" || value === null || typeof value === "undefined") {
+			return true;
+		}
+		var reg = new RegExp(parameters);
+
+		return reg.test(value);
+	},
+
+	//value must be unique in this column
+	unique: function unique(cell, value, parameters) {
+		if (value === "" || value === null || typeof value === "undefined") {
+			return true;
+		}
+		var unique = true;
+
+		var cellData = cell.getData();
+		var column = cell.getColumn()._getSelf();
+
+		this.table.rowManager.rows.forEach(function (row) {
+			var data = row.getData();
+
+			if (data !== cellData) {
+				if (value == column.getFieldValue(data)) {
+					unique = false;
+				}
+			}
+		});
+
+		return unique;
+	},
+
+	//must have a value
+	required: function required(cell, value, parameters) {
+		return value !== "" && value !== null && typeof value !== "undefined";
+	}
+};
+
+Tabulator.prototype.registerModule("validate", Validate);

public/assets/vendors/tabulator/js/modules/validate.min.js

@@ -0,0 +1,2 @@
+/* Tabulator v4.9.3 (c) Oliver Folkerd */
+var _typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},Validate=function(t){this.table=t,this.invalidCells=[]};Validate.prototype.initializeColumn=function(t){var i,n=this,e=[];t.definition.validator&&(Array.isArray(t.definition.validator)?t.definition.validator.forEach(function(t){(i=n._extractValidator(t))&&e.push(i)}):(i=this._extractValidator(t.definition.validator))&&e.push(i),t.modules.validate=!!e.length&&e)},Validate.prototype._extractValidator=function(t){var i,n,e;switch(void 0===t?"undefined":_typeof(t)){case"string":return e=t.indexOf(":"),e>-1?(i=t.substring(0,e),n=t.substring(e+1)):i=t,this._buildValidator(i,n);case"function":return this._buildValidator(t);case"object":return this._buildValidator(t.type,t.parameters)}},Validate.prototype._buildValidator=function(t,i){var n="function"==typeof t?t:this.validators[t];return n?{type:"function"==typeof t?"function":t,func:n,params:i}:(console.warn("Validator Setup Error - No matching validator found:",t),!1)},Validate.prototype.validate=function(t,i,n){var e=this,a=[],o=this.invalidCells.indexOf(i);return t&&t.forEach(function(t){t.func.call(e,i.getComponent(),n,t.params)||a.push({type:t.type,parameters:t.params})}),a=!a.length||a,i.modules.validate||(i.modules.validate={}),!0===a?(i.modules.validate.invalid=!1,i.getElement().classList.remove("tabulator-validation-fail"),o>-1&&this.invalidCells.splice(o,1)):(i.modules.validate.invalid=!0,"manual"!==this.table.options.validationMode&&i.getElement().classList.add("tabulator-validation-fail"),-1==o&&this.invalidCells.push(i)),a},Validate.prototype.getInvalidCells=function(){var t=[];return this.invalidCells.forEach(function(i){t.push(i.getComponent())}),t},Validate.prototype.clearValidation=function(t){var i;t.modules.validate&&t.modules.validate.invalid&&(t.getElement().classList.remove("tabulator-validation-fail"),t.modules.validate.invalid=!1,(i=this.invalidCells.indexOf(t))>-1&&this.invalidCells.splice(i,1))},Validate.prototype.validators={integer:function(t,i,n){return""===i||null===i||void 0===i||"number"==typeof(i=Number(i))&&isFinite(i)&&Math.floor(i)===i},float:function(t,i,n){return""===i||null===i||void 0===i||"number"==typeof(i=Number(i))&&isFinite(i)&&i%1!=0},numeric:function(t,i,n){return""===i||null===i||void 0===i||!isNaN(i)},string:function(t,i,n){return""===i||null===i||void 0===i||isNaN(i)},max:function(t,i,n){return""===i||null===i||void 0===i||parseFloat(i)<=n},min:function(t,i,n){return""===i||null===i||void 0===i||parseFloat(i)>=n},starts:function(t,i,n){return""===i||null===i||void 0===i||String(i).toLowerCase().startsWith(String(n).toLowerCase())},ends:function(t,i,n){return""===i||null===i||void 0===i||String(i).toLowerCase().endsWith(String(n).toLowerCase())},minLength:function(t,i,n){return""===i||null===i||void 0===i||String(i).length>=n},maxLength:function(t,i,n){return""===i||null===i||void 0===i||String(i).length<=n},in:function(t,i,n){return""===i||null===i||void 0===i||("string"==typeof n&&(n=n.split("|")),""===i||n.indexOf(i)>-1)},regex:function(t,i,n){return""===i||null===i||void 0===i||new RegExp(n).test(i)},unique:function(t,i,n){if(""===i||null===i||void 0===i)return!0;var e=!0,a=t.getData(),o=t.getColumn()._getSelf();return this.table.rowManager.rows.forEach(function(t){var n=t.getData();n!==a&&i==o.getFieldValue(n)&&(e=!1)}),e},required:function(t,i,n){return""!==i&&null!==i&&void 0!==i}},Tabulator.prototype.registerModule("validate",Validate);