tabulator-tables 5.0.7 → 5.1.0

package/dist/js/tabulator_esm.js

@@ -1,4 +1,4 @@
-/* Tabulator v5.0.7 (c) Oliver Folkerd 2021 */
+/* Tabulator v5.1.0 (c) Oliver Folkerd 2022 */
 class CoreFeature{
 
 	constructor(table){
@@ -103,11 +103,7 @@ class CoreFeature{
 	//////////////// Options /////////////////
 	//////////////////////////////////////////
 
-	options(key, value){
-		if(typeof value !== "undefined"){
-			this.table.options[key] = value;
-		}
-
+	options(key){
 		return this.table.options[key];
 	}
 
@@ -539,144 +535,125 @@ var defaultContentTypeFormatters = {
 };
 
 class Ajax extends Module{
-
+	
 	constructor(table){
 		super(table);
-
-		this.config = false; //hold config object for ajax request
+		
+		this.config = {}; //hold config object for ajax request
 		this.url = ""; //request URL
 		this.urlGenerator = false;
 		this.params = false; //request parameters
-
+		
 		this.loaderPromise = false;
-
+		
 		this.registerTableOption("ajaxURL", false); //url for ajax loading
 		this.registerTableOption("ajaxURLGenerator", false);
 		this.registerTableOption("ajaxParams", {});  //params for ajax loading
 		this.registerTableOption("ajaxConfig", "get"); //ajax request type
 		this.registerTableOption("ajaxContentType", "form"); //ajax request type
 		this.registerTableOption("ajaxRequestFunc", false); //promise function
-
+		
 		this.registerTableOption("ajaxRequesting", function(){});
 		this.registerTableOption("ajaxResponse", false);
-
+		
 		this.contentTypeFormatters = Ajax.contentTypeFormatters;
 	}
-
+	
 	//initialize setup options
 	initialize(){
 		this.loaderPromise = this.table.options.ajaxRequestFunc || Ajax.defaultLoaderPromise;
 		this.urlGenerator = this.table.options.ajaxURLGenerator || Ajax.defaultURLGenerator;
-
-		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);
 		}
 
-		this.registerTableFunction("getAjaxUrl", this.getUrl.bind(this));
 
+		this.setDefaultConfig(this.table.options.ajaxConfig);
+		
+		this.registerTableFunction("getAjaxUrl", this.getUrl.bind(this));
+		
 		this.subscribe("data-loading", this.requestDataCheck.bind(this));
+		this.subscribe("data-params", this.requestParams.bind(this));
 		this.subscribe("data-load", this.requestData.bind(this));
 	}
-
-
+	
+	requestParams(data, config, silent, params){
+		var ajaxParams = this.table.options.ajaxParams;
+		
+		if(ajaxParams){
+			if(typeof ajaxParams === "function"){
+				ajaxParams = ajaxParams.call(this.table);
+			}
+			
+			params = Object.assign(params, ajaxParams);
+		}		
+		
+		return params;
+	}
+	
 	requestDataCheck(data, params, config, silent){
 		return !!((!data && this.url) || typeof data === "string");
 	}
-
-	requestData(data, params, config, silent, previousData){
-		if(this.requestDataCheck(data)){
-			if(data){
-				this.setUrl(data);
-			}
-
-			if(params){
-				this.setParams(params, true);
-			}
-
-			if(config){
-				this.setConfig(config);
-			}
-
-			return this.sendRequest();
+	
+	requestData(url, params, config, silent, previousData){
+		var ajaxConfig;
+		
+		if(!previousData && this.requestDataCheck(url)){
+			if(url){
+				this.setUrl(url);
+			}
+			
+			ajaxConfig = this.generateConfig(config);
+			
+			return this.sendRequest(this.url, params, ajaxConfig);
 		}else {
 			return previousData;
 		}
 	}
+	
+	setDefaultConfig(config = {}){
+		this.config = Object.assign({}, Ajax.defaultConfig);
 
-	//set ajax params
-	setParams(params, update){
-		if(update){
-			this.params = this.params || {};
-
-			for(let key in params){
-				this.params[key] = params[key];
-			}
+		if(typeof config == "string"){
+			this.config.method = config;
 		}else {
-			this.params = params;
+			Object.assign(this.config, config);
 		}
 	}
-
-	getParams(){
-		return this.params || {};
-	}
-
+	
 	//load config object
-	setConfig(config){
-		this._loadDefaultConfig();
-
+	generateConfig(config = {}){
+		var ajaxConfig = Object.assign({}, this.config);
+		
 		if(typeof config == "string"){
-			this.config.method = config;
+			ajaxConfig.method = config;
 		}else {
-			for(let key in config){
-				this.config[key] = config[key];
-			}
-		}
-	}
-
-	//create config object from default
-	_loadDefaultConfig(force){
-		if(!this.config || force){
-
-			this.config = {};
-
-			//load base config from defaults
-			for(let key in Ajax.defaultConfig){
-				this.config[key] = Ajax.defaultConfig[key];
-			}
+			Object.assign(ajaxConfig, config);
 		}
+		
+		return ajaxConfig;
 	}
-
+	
 	//set request url
 	setUrl(url){
 		this.url = url;
 	}
-
+	
 	//get request url
 	getUrl(){
 		return this.url;
 	}
-
+	
 	//send ajax request
-	sendRequest(silent){
-		var url = this.url;
-
-		this._loadDefaultConfig();
-
-		if(this.table.options.ajaxRequesting.call(this.table, this.url, this.params) !== false){
-			return this.loaderPromise(url, this.config, this.params)
+	sendRequest(url, params, config){
+		if(this.table.options.ajaxRequesting.call(this.table, url, params) !== false){
+			return this.loaderPromise(url, config, params)
 			.then((data)=>{
 				if(this.table.options.ajaxResponse){
-					data = this.table.options.ajaxResponse.call(this.table, this.url, this.params, data);
+					data = this.table.options.ajaxResponse.call(this.table, url, params, data);
 				}
-
+				
 				return data;
 			});
 		}else {
@@ -1370,6 +1347,10 @@ class Cell extends CoreFeature{
 
 			this.cellRendered();
 
+			if(this.column.definition.cellEdited){
+				this.column.definition.cellEdited.call(this.table, this.getComponent());
+			}
+
 			this.dispatchExternal("cellEdited", this.getComponent());
 
 			if(this.subscribedExternal("dataChanged")){
@@ -1381,7 +1362,7 @@ class Cell extends CoreFeature{
 	setValueProcessData(value, mutate){
 		var changed = false;
 
-		if(this.value != value){
+		if(this.value !== value){
 
 			changed = true;
 
@@ -1529,6 +1510,10 @@ class ColumnComponent {
 		return this._column.getField();
 	}
 
+	getTitleDownload() {
+		return this._column.getTitleDownload();
+	}
+
 	getCells(){
 		var cells = [];
 
@@ -1648,7 +1633,7 @@ class ColumnComponent {
 	}
 }
 
-var defaultOptions = {
+var defaultColumnOptions = {
 	"title": undefined,
 	"field": undefined,
 	"columns": undefined,
@@ -1658,6 +1643,7 @@ var defaultOptions = {
 	"width": undefined,
 	"minWidth": 40,
 	"maxWidth": undefined,
+	"maxInitialWidth": undefined,
 	"tooltip": undefined,
 	"cssClass": undefined,
 	"variableHeight": undefined,
@@ -1693,6 +1679,7 @@ class Column$1 extends CoreFeature{
 		this.getFieldValue = "";
 		this.setFieldValue = "";
 
+		this.titleDownload = null;
 		this.titleFormatterRendered = false;
 
 		this.mapDefinitions();
@@ -1705,6 +1692,7 @@ class Column$1 extends CoreFeature{
 		this.widthStyled = ""; //column width prestyled to improve render efficiency
 		this.maxWidth = null; //column maximum width
 		this.maxWidthStyled = ""; //column maximum prestyled to improve render efficiency
+		this.maxInitialWidth = null;
 		this.minWidth = null; //column minimum width
 		this.minWidthStyled = ""; //column minimum prestyled to improve render efficiency
 		this.widthFixed = false; //user has specified a width for this column
@@ -1810,7 +1798,7 @@ class Column$1 extends CoreFeature{
 		var def = this.definition;
 
 		//set header tooltips
-		var tooltip = typeof def.headerTooltip === "undefined" ? def.tooltip : def.headerTooltip;
+		var tooltip = def.headerTooltip;
 
 		if(tooltip){
 			if(tooltip === true){
@@ -1983,6 +1971,10 @@ class Column$1 extends CoreFeature{
 		//set min width if present
 		this.setMinWidth(parseInt(def.minWidth));
 
+		if (def.maxInitialWidth) {
+			this.maxInitialWidth = parseInt(def.maxInitialWidth);
+		}
+		
 		if(def.maxWidth){
 			this.setMaxWidth(parseInt(def.maxWidth));
 		}
@@ -2233,6 +2225,10 @@ class Column$1 extends CoreFeature{
 		return this.field;
 	}
 
+	getTitleDownload() {
+		return this.titleDownload;
+	}
+
 	//return the first column in a group
 	getFirstColumn(){
 		if(!this.isGroup){
@@ -2365,7 +2361,7 @@ class Column$1 extends CoreFeature{
 				cell.hide();
 			});
 
-			this.dispatch("column-hide", this);
+			this.dispatch("column-hide", this, responsiveToggle);
 
 			if(!silent){
 				this.dispatchExternal("columnVisibilityChanged", this.getComponent(), false);
@@ -2485,7 +2481,7 @@ class Column$1 extends CoreFeature{
 	}
 
 	getHeight(){
-		return this.element.offsetHeight;
+		return Math.ceil(this.element.getBoundingClientRect().height);
 	}
 
 	setMinWidth(minWidth){
@@ -2589,18 +2585,19 @@ class Column$1 extends CoreFeature{
 
 		//set width if present
 		if(typeof this.definition.width !== "undefined" && !force){
+			// maxInitialWidth ignored here as width specified
 			this.setWidth(this.definition.width);
 		}
 
 		this.dispatch("column-width-fit-before", this);
 
-		this.fitToData();
+		this.fitToData(force);
 
 		this.dispatch("column-width-fit-after", this);
 	}
 
 	//set column width to maximum cell width for non group columns
-	fitToData(){
+	fitToData(force){
 		if(this.isGroup){
 			return;
 		}
@@ -2625,7 +2622,11 @@ class Column$1 extends CoreFeature{
 			});
 
 			if(maxWidth){
-				this.setWidthActual(maxWidth + 1);
+				var setTo = maxWidth + 1;
+				if (this.maxInitialWidth && !force) {
+					setTo = Math.min(setTo, this.maxInitialWidth);
+				}
+				this.setWidthActual(setTo);
 			}
 		}
 	}
@@ -2679,7 +2680,7 @@ class Column$1 extends CoreFeature{
 	}
 }
 
-Column$1.defaultOptionList = defaultOptions;
+Column$1.defaultOptionList = defaultColumnOptions;
 
 //public row object
 class RowComponent$1 {
@@ -2854,12 +2855,12 @@ class Row extends CoreFeature{
 
 			this.dispatch("row-layout", this);
 
+			this.initialized = true;
+
 			if(this.table.options.rowFormatter){
 				this.table.options.rowFormatter(this.getComponent());
 			}
 
-			this.initialized = true;
-
 			this.dispatch("row-layout-after", this);
 		}else {
 			this.table.columnManager.renderer.rerenderRowCells(this);
@@ -3323,8 +3324,9 @@ class ColumnCalcs extends Module{
 		this.subscribe("row-added", this.rowsUpdated.bind(this));
 		this.subscribe("column-moved", this.recalcActiveRows.bind(this));
 		this.subscribe("column-add", this.recalcActiveRows.bind(this));
-		this.subscribe("data-refeshed", this.recalcActiveRows.bind(this));
+		this.subscribe("data-refreshed", this.recalcActiveRows.bind(this));
 		this.subscribe("table-redraw", this.tableRedraw.bind(this));
+		this.subscribe("rows-visible", this.visibleRows.bind(this));
 
 		this.registerTableFunction("getCalcResults", this.getResults.bind(this));
 		this.registerTableFunction("recalc", this.userRecalc.bind(this));
@@ -3350,6 +3352,18 @@ class ColumnCalcs extends Module{
 	///////// Internal Logic //////////
 	///////////////////////////////////
 
+	visibleRows(viewable, rows){
+		if(this.topRow){
+			rows.unshift(this.topRow);
+		}
+
+		if(this.botRow){
+			rows.push(this.botRow);
+		}
+	
+		return rows;
+	}
+
 	rowsUpdated(row){
 		if(this.table.options.groupBy){
 			this.recalcRowGroup(this);
@@ -3626,7 +3640,7 @@ class ColumnCalcs extends Module{
 
 		row.getComponent = () => {
 			if(!row.component){
-				row.component = new CalcComponent(this);
+				row.component = new CalcComponent(row);
 			}
 
 			return row.component;
@@ -3803,17 +3817,16 @@ class DataTree extends Module{
 		this.registerComponentFunction("row", "getTreeParent", this.getTreeParent.bind(this));
 		this.registerComponentFunction("row", "getTreeChildren", this.getRowChildren.bind(this));
 		this.registerComponentFunction("row", "addTreeChild", this.addTreeChildRow.bind(this));
+		this.registerComponentFunction("row", "isTreeExpanded", this.isRowExpanded.bind(this));
 	}
 
 	initialize(){
 		if(this.table.options.dataTree){
 			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){
 
@@ -3882,15 +3895,23 @@ class DataTree extends Module{
 
 			this.subscribe("row-init", this.initializeRow.bind(this));
 			this.subscribe("row-layout-after", this.layoutRow.bind(this));
-			this.subscribe("row-relayout", this.layoutRow.bind(this));
 			this.subscribe("row-deleted", this.rowDelete.bind(this),0);
 			this.subscribe("row-data-changed", this.rowDataChanged.bind(this), 10);
+			this.subscribe("cell-value-updated", this.cellValueChanged.bind(this));
+			this.subscribe("edit-cancelled", this.cellValueChanged.bind(this));
 			this.subscribe("column-moving-rows", this.columnMoving.bind(this));
+			this.subscribe("table-built", this.initializeElementField.bind(this));
 
 			this.registerDisplayHandler(this.getRows.bind(this), 30);
 		}
 	}
 
+	initializeElementField(){
+		var firstCol = this.table.columnManager.getFirstVisibleColumn();
+
+		this.elementField = this.table.options.dataTreeElementColumn || (firstCol ? firstCol.field : false);
+	}
+	
 	getRowChildren(row){
 		return this.getTreeChildren(row, true);
 	}
@@ -3916,6 +3937,14 @@ class DataTree extends Module{
 		}
 	}
 
+	cellValueChanged(cell){
+		var field = cell.column.getField();
+
+		if(field === this.elementField){
+			this.layoutRow(cell.row);
+		}
+	}
+
 	initializeRow(row){
 		var childArray = row.getData()[this.field];
 		var isArray = Array.isArray(childArray);
@@ -4161,6 +4190,10 @@ class DataTree extends Module{
 		}
 	}
 
+	isRowExpanded(row){
+		return row.modules.dataTree.open;
+	}
+
 	getTreeParent(row){
 		return row.modules.dataTree.parent ? row.modules.dataTree.parent.getComponent() : false;
 	}
@@ -4320,17 +4353,12 @@ class DataTree extends Module{
 		return output;
 	}
 
-	checkForRestyle(cell){
-		if(!cell.row.cells.indexOf(cell)){
-			this.layoutRow(cell.row);
-		}
-	}
-
 	getChildField(){
 		return this.field;
 	}
 
 	redrawNeeded(data){
+		console.log("needed?", data);
 		return (this.field ? typeof data[this.field] !== "undefined" : false) || (this.elementField ? typeof data[this.elementField] !== "undefined" : false);
 	}
 }
@@ -4421,7 +4449,7 @@ function json(list, options, setFileContents){
 			case "row":
 			row.columns.forEach((col) => {
 				if(col){
-					item[col.component.getField()] = col.value;
+					item[col.component.getTitleDownload() || col.component.getField()] = col.value;
 				}
 			});
 
@@ -4513,8 +4541,6 @@ function pdf(list, options, setFileContents){
 				}
 
 				rowData.push(cell);
-			}else {
-				rowData.push("");
 			}
 		});
 
@@ -4577,7 +4603,9 @@ function xlsx(list, options, setFileContents){
 					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}});
+						if(col.height > 1 || col.width > 1){
+							merges.push({s:{r:i,c:j},e:{r:i + col.height - 1,c:j + col.width - 1}});
+						}
 					}
 				}else {
 					rowData.push("");
@@ -4587,7 +4615,6 @@ function xlsx(list, options, setFileContents){
 			rows.push(rowData);
 		});
 
-
 		//convert rows to worksheet
 		XLSX.utils.sheet_add_aoa(worksheet, rows);
 
@@ -4653,9 +4680,43 @@ function html(list, options, setFileContents){
 	}
 }
 
+function jsonLines (list, options, setFileContents) {
+	const fileContents = [];
+
+	list.forEach((row) => {
+		const 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((col) => {
+					if (col) {
+						item[col.component.getTitleDownload() || col.component.getField()] = col.value;
+					}
+				});
+
+				fileContents.push(JSON.stringify(item));
+				break;
+		}
+	});
+
+	setFileContents(fileContents.join("\n"), "application/x-ndjson");
+}
+
 var defaultDownloaders = {
 	csv:csv,
 	json:json,
+	jsonLines:jsonLines,
 	pdf:pdf,
 	xlsx:xlsx,
 	html:html,
@@ -6422,8 +6483,8 @@ function star(cell, onRendered, success, cancel, editorParams){
 //draggable progress bar
 function progress(cell, onRendered, success, cancel, editorParams){
 	var element = cell.getElement(),
-	max = typeof editorParams.max === "undefined" ? ( element.getElementsByTagName("div")[0]?.getAttribute("max") || 100) : editorParams.max,
-	min = typeof editorParams.min === "undefined" ? ( element.getElementsByTagName("div")[0]?.getAttribute("min") || 0) : editorParams.min,
+	max = typeof editorParams.max === "undefined" ? ((element.getElementsByTagName("div")[0] && element.getElementsByTagName("div")[0].getAttribute("max")) || 100) : editorParams.max,
+	min = typeof editorParams.min === "undefined" ? ((element.getElementsByTagName("div")[0] && element.getElementsByTagName("div")[0].getAttribute("min")) || 0) : editorParams.min,
 	percent = (max - min) / 100,
 	value = cell.getValue() || 0,
 	handle = document.createElement("div"),
@@ -6698,12 +6759,12 @@ class Edit extends Module{
 		this.subscribe("row-deleting", this.rowDeleteCheck.bind(this));
 		this.subscribe("data-refeshing", this.cancelEdit.bind(this));
 
-		this.subscribe("keybinding-nav-prev", this.navigatePrev.bind(this));
+		this.subscribe("keybinding-nav-prev", this.navigatePrev.bind(this, undefined));
 		this.subscribe("keybinding-nav-next", this.keybindingNavigateNext.bind(this));
-		this.subscribe("keybinding-nav-left", this.navigateLeft.bind(this));
-		this.subscribe("keybinding-nav-right", this.navigateRight.bind(this));
-		this.subscribe("keybinding-nav-up", this.navigateUp.bind(this));
-		this.subscribe("keybinding-nav-down", this.navigateDown.bind(this));
+		this.subscribe("keybinding-nav-left", this.navigateLeft.bind(this, undefined));
+		this.subscribe("keybinding-nav-right", this.navigateRight.bind(this, undefined));
+		this.subscribe("keybinding-nav-up", this.navigateUp.bind(this, undefined));
+		this.subscribe("keybinding-nav-down", this.navigateDown.bind(this, undefined));
 	}
 
 
@@ -6716,9 +6777,9 @@ class Edit extends Module{
 		newRow = this.options("tabEndNewRow");
 
 		if(cell){
-			if(!this.navigateNext(e)){
+			if(!this.navigateNext(cell, e)){
 				if(newRow){
-					cell.getElement().firstChild.blur();
+					// cell.getElement().firstChild.blur();
 
 					if(newRow === true){
 						newRow = this.table.addRow({});
@@ -6732,7 +6793,7 @@ class Edit extends Module{
 
 					newRow.then(() => {
 						setTimeout(() => {
-							nav.next();
+							cell.getComponent().navigateNext();
 						});
 					});
 				}
@@ -6762,7 +6823,7 @@ class Edit extends Module{
 	///////////////////////////////////
 	clearCellEdited(cells){
 		if(!cells){
-			cells = this.modules.edit.getEditedCells();
+			cells = this.table.modules.edit.getEditedCells();
 		}
 
 		if(!Array.isArray(cells)){
@@ -6770,13 +6831,12 @@ class Edit extends Module{
 		}
 
 		cells.forEach((cell) => {
-			this.modules.edit.clearEdited(cell._getSelf());
+			this.table.modules.edit.clearEdited(cell._getSelf());
 		});
 	}
 
-	navigatePrev(e){
-		var cell = this.currentCell,
-		nextCell, prevRow;
+	navigatePrev(cell = this.currentCell, e){
+		var nextCell, prevRow;
 
 		if(cell){
 
@@ -6805,9 +6865,8 @@ class Edit extends Module{
 		return false;
 	}
 
-	navigateNext(e){
-		var cell = this.currentCell,
-		nextCell, nextRow;
+	navigateNext(cell = this.currentCell, e){
+		var nextCell, nextRow;
 
 		if(cell){
 
@@ -6836,9 +6895,8 @@ class Edit extends Module{
 		return false;
 	}
 
-	navigateLeft(e){
-		var cell = this.currentCell,
-		index, nextCell;
+	navigateLeft(cell = this.currentCell, e){
+		var index, nextCell;
 
 		if(cell){
 
@@ -6858,9 +6916,8 @@ class Edit extends Module{
 		return false;
 	}
 
-	navigateRight(e){
-		var cell = this.currentCell,
-		index, nextCell;
+	navigateRight(cell = this.currentCell, e){
+		var index, nextCell;
 
 		if(cell){
 
@@ -6880,9 +6937,8 @@ class Edit extends Module{
 		return false;
 	}
 
-	navigateUp(e){
-		var cell = this.currentCell,
-		index, nextRow;
+	navigateUp(cell = this.currentCell, e){
+		var index, nextRow;
 
 		if(cell){
 
@@ -6902,9 +6958,8 @@ class Edit extends Module{
 		return false;
 	}
 
-	navigateDown(e){
-		var cell = this.currentCell,
-		index, nextRow;
+	navigateDown(cell = this.currentCell, e){
+		var index, nextRow;
 
 		if(cell){
 
@@ -7054,14 +7109,15 @@ class Edit extends Module{
 			cellEl = cell.getElement();
 
 			if(cancel){
-				if(cell.validate){
-					cell.validate();
+				if(cell.column.modules.validate && this.table.modExists("validate")){
+					this.table.modules.validate.cellValidate(cell);
 				}
 			}else {
 				cellEl.classList.remove("tabulator-validation-fail");
 			}
 
 			cellEl.classList.remove("tabulator-editing");
+
 			while(cellEl.firstChild) cellEl.removeChild(cellEl.firstChild);
 
 			cell.row.getElement().classList.remove("tabulator-row-editing");
@@ -7085,6 +7141,7 @@ class Edit extends Module{
 				cell.column.definition.cellEditCancelled.call(this.table, component);
 			}
 
+			this.dispatch("edit-cancelled", cell);
 			this.dispatchExternal("cellEditCancelled", component);
 		}
 	}
@@ -7215,10 +7272,6 @@ class Edit extends Module{
 
 					cell.setValue(value, true);
 
-					if(self.table.options.dataTree && self.table.modExists("dataTree")){
-						self.table.modules.dataTree.checkForRestyle(cell);
-					}
-
 					if(valid !== true){
 						element.classList.add("tabulator-validation-fail");
 						self.table.externalEvents.dispatch("validationFailed", cell.getComponent(), value, valid);
@@ -7241,10 +7294,6 @@ class Edit extends Module{
 		function cancel(){
 			if(self.currentCell === cell){
 				self.cancelEdit();
-
-				if(self.table.options.dataTree && self.table.modExists("dataTree")){
-					self.table.modules.dataTree.checkForRestyle(cell);
-				}
 			}
 		}
 
@@ -7452,7 +7501,7 @@ class Export extends Module{
 			switch(range){
 				case true:
 				case "visible":
-				rows = this.table.rowManager.getVisibleRows(true);
+				rows = this.table.rowManager.getVisibleRows(false, true);
 				break;
 
 				case "all":
@@ -8484,7 +8533,7 @@ class Filter extends Module{
 
 				params = column.definition.headerFilterParams || {};
 
-				params = typeof params === "function" ? params.call(self.table) : params;
+				params = typeof params === "function" ? params.call(self.table, cellWrapper) : params;
 
 				editorElement = editor.call(this.table.modules.edit, cellWrapper, function(){}, success, cancel, params);
 
@@ -8655,7 +8704,7 @@ class Filter extends Module{
 			if(this.table.options.filterMode === "remote"){
 				this.reloadData();
 			}else {
-				this.refreshData();
+				this.refreshData(true);
 			}
 		}
 
@@ -9173,7 +9222,7 @@ function datetime(cell, formatterParams, onRendered){
 	var value = cell.getValue();
 
 	if(typeof DT != "undefined"){
-		var newDatetime = (window.DateTime || luxon.DateTime).fromFormat(value, inputFormat);
+		var newDatetime = inputFormat === "iso" ? DT.fromISO(String(value)) : DT.fromFormat(String(value), inputFormat);
 
 		if(newDatetime.isValid){
 
@@ -9184,7 +9233,7 @@ function datetime(cell, formatterParams, onRendered){
 			return newDatetime.toFormat(outputFormat);
 		}else {
 
-			if(invalid === true){
+			if(invalid === true || !value){
 				return value;
 			}else if(typeof invalid === "function"){
 				return invalid(value);
@@ -9208,7 +9257,8 @@ function datetimediff (cell, formatterParams, onRendered) {
 	var value = cell.getValue();
 
 	if(typeof DT != "undefined"){
-		var newDatetime = DT.fromFormat(value, inputFormat);
+		
+		var newDatetime = inputFormat === "iso" ? DT.fromISO(String(value)) : DT.fromFormat(String(value), inputFormat);
 
 		if (newDatetime.isValid){
 			if(humanize);else {
@@ -9821,7 +9871,7 @@ class FrozenColumns extends Module{
 		this.subscribe("cell-layout", this.layoutCell.bind(this));
 		this.subscribe("column-init", this.initializeColumn.bind(this));
 		this.subscribe("column-width", this.layout.bind(this));
-		this.subscribe("row-layout-before", this.layoutRow.bind(this));
+		this.subscribe("row-layout-after", this.layoutRow.bind(this));
 		this.subscribe("table-layout", this.layout.bind(this));
 		this.subscribe("scroll-horizontal", this.scrollHorizontal.bind(this));
 		this.subscribe("columns-loading", this.reset.bind(this));
@@ -10105,6 +10155,7 @@ class FrozenRows extends Module{
 		this.table.columnManager.getElement().insertBefore(this.topElement, this.table.columnManager.headersElement.nextSibling);
 
 		this.subscribe("row-deleting", this.detachRow.bind(this));
+		this.subscribe("rows-visible", this.visibleRows.bind(this));
 
 		this.registerDisplayHandler(this.getRows.bind(this), 10);
 	}
@@ -10118,6 +10169,14 @@ class FrozenRows extends Module{
 		return !!this.rows.length;
 	}
 
+	visibleRows(viewable, rows){
+		this.rows.forEach((row) => {
+			rows.push(row);
+		});
+
+		return rows;
+	}
+
 	//filter frozen rows out of display data
 	getRows(rows){
 		var output = rows.slice(0);
@@ -10280,6 +10339,7 @@ class Group{
 		this.groups = [];
 		this.groupList = [];
 		this.generator = generator;
+		this.element = false;
 		this.elementContents = false;
 		this.height = 0;
 		this.outerHeight = 0;
@@ -10305,10 +10365,16 @@ class Group{
 				group.wipe();
 			});
 		}else {
-			this.element = false;
-			this.arrowElement = false;
-			this.elementContents = false;
+			this.rows.forEach((row) => {
+				if(row.modules){
+					delete row.modules.group;
+				}
+			});
 		}
+
+		this.element = false;
+		this.arrowElement = false;
+		this.elementContents = false;
 	}
 
 	createElements(){
@@ -10341,67 +10407,7 @@ class Group{
 	}
 
 	addBindings(){
-		var dblTap,	tapHold, tap, toggleElement;
-
-		if ((this.groupManager.table.options.groupContextMenu || this.groupManager.table.options.groupClickMenu) && this.groupManager.table.modExists("menu")){
-			this.groupManager.table.modules.menu.initializeGroup.call(this.groupManager.table.modules.menu, this);
-		}
-
-		if (this.groupManager.table.options.groupTap){
-			tap = false;
-
-			this.element.addEventListener("touchstart", (e) => {
-				tap = true;
-			}, {passive: true});
-
-			this.element.addEventListener("touchend", (e) => {
-				if(tap){
-					this.groupManager.table.options.groupTap(e, this.getComponent());
-				}
-
-				tap = false;
-			});
-		}
-
-		if (this.groupManager.table.options.groupDblTap){
-			dblTap = null;
-
-			this.element.addEventListener("touchend", (e) => {
-				if(dblTap){
-					clearTimeout(dblTap);
-					dblTap = null;
-
-					this.groupManager.table.options.groupDblTap(e, this.getComponent());
-				}else {
-
-					dblTap = setTimeout(() => {
-						clearTimeout(dblTap);
-						dblTap = null;
-					}, 300);
-				}
-			});
-		}
-
-		if (this.groupManager.table.options.groupTapHold){
-			tapHold = null;
-
-			this.element.addEventListener("touchstart", (e) => {
-				clearTimeout(tapHold);
-
-				tapHold = setTimeout(() => {
-					clearTimeout(tapHold);
-					tapHold = null;
-					tap = false;
-					this.groupManager.table.options.groupTapHold(e, this.getComponent());
-				}, 1000);
-
-			}, {passive: true});
-
-			this.element.addEventListener("touchend", (e) => {
-				clearTimeout(tapHold);
-				tapHold = null;
-			});
-		}
+		var toggleElement;
 
 		if(this.groupManager.table.options.groupToggleElement){
 			toggleElement = this.groupManager.table.options.groupToggleElement == "arrow" ? this.arrowElement : this.element;
@@ -10530,7 +10536,7 @@ class Group{
 			}
 
 			this.generateGroupHeaderContents();
-
+			
 			if(this.groupManager.table.modExists("columnCalcs") && this.groupManager.table.options.columnCalcs != "table"){
 				this.groupManager.table.modules.columnCalcs.recalcGroup(this);
 			}
@@ -10710,7 +10716,7 @@ class Group{
 
 			this.element.classList.add("tabulator-group-visible");
 
-			var prev = this.getElement();
+			var prev = this.generateElement();
 
 			if(this.groupList.length){
 				this.groupList.forEach((group) => {
@@ -10828,7 +10834,11 @@ class Group{
 	////////////// Standard Row Functions //////////////
 
 	getElement(){
-		this.addBindingsd = false;
+		return this.elementContents ? this.element : this.generateElement();
+	}
+
+	generateElement(){
+		this.addBindings = false;
 
 		this._visSet();
 
@@ -10956,13 +10966,13 @@ class GroupRows extends Module{
 	initialize(){
 		if(this.table.options.groupBy){
 
-			this.configureGroupSetup();
-
 			if(this.table.options.groupUpdateOnCellEdit){
 				this.subscribe("cell-value-updated", this.cellUpdated.bind(this));
 				this.subscribe("row-data-changed", this.reassignRowToGroup.bind(this), 0);
 			}
 
+			this.subscribe("table-built", this.configureGroupSetup.bind(this));
+			
 			this.subscribe("row-deleting", this.rowDeleting.bind(this));
 			this.subscribe("row-deleted", this.rowsUpdated.bind(this));
 			this.subscribe("scroll-horizontal", this.scrollHeaders.bind(this));
@@ -11133,7 +11143,12 @@ class GroupRows extends Module{
 
 	setGroupBy(groups){
 		this.table.options.groupBy = groups;
-		this.configureGroupSetup();
+		if(!this.initialized){
+			this.initialize();
+		}else {
+			this.configureGroupSetup();
+		}
+
 		this.refreshData();
 
 		this.trackChanges();
@@ -11733,7 +11748,7 @@ class HtmlTableImport extends Module{
 
 		rows = rows ? rows.getElementsByTagName("tr") : [];
 
-		//check for tablator inline options
+		//check for Tabulator inline options
 		this._extractOptions(element, options);
 
 		if(headers.length){
@@ -11772,7 +11787,7 @@ class HtmlTableImport extends Module{
 	//extract tabulator attribute options
 	_extractOptions(element, options, defaultOptions){
 		var attributes = element.attributes;
-		var optionsArr = defaultOptions ? Object.assign([], defaultOptions) : Object.keys(options);
+		var optionsArr = defaultOptions ? Object.keys(defaultOptions) : Object.keys(options);
 		var optionsList = {};
 
 		optionsArr.forEach((item) => {
@@ -11839,11 +11854,8 @@ class HtmlTableImport extends Module{
 				col.width = width;
 			}
 
-			//check for tablator inline options
-			header.attributes;
-
-			// //check for tablator inline options
-			this._extractOptions(header, col, Column$1.prototype.defaultOptionList);
+			//check for Tabulator inline options
+			this._extractOptions(header, col, this.table.columnManager.optionsList.registeredDefaults);
 
 			this.fieldIndex[index] = col.field;
 
@@ -11879,40 +11891,307 @@ class HtmlTableImport extends Module{
 
 HtmlTableImport.moduleName = "htmlTableImport";
 
-class Interaction extends Module{
+function csvImporter(input){
+    var data = [],
+    row = 0, 
+    col = 0,
+    inQuote = false;
+    
+    //Iterate over each character
+    for (let index = 0; index < input.length; index++) {
+        let char = input[index], 
+        nextChar = input[index+1];      
+        
+        //Initialize empty row
+        if(!data[row]){
+            data[row] = [];
+        }
 
-	constructor(table){
-		super(table);
+        //Initialize empty column
+        if(!data[row][col]){
+            data[row][col] = "";
+        }
+        
+        //Handle quotation mark inside string
+        if (char == '"' && inQuote && nextChar == '"') { 
+            data[row][col] += char; 
+            index++;
+            continue; 
+        }
+        
+        //Begin / End Quote
+        if (char == '"') { 
+            inQuote = !inQuote;
+            continue;
+        }
+        
+        //Next column (if not in quote)
+        if (char == ',' && !inQuote) { 
+            col++;
+            continue; 
+        }
+        
+        //New row if new line and not in quote (CRLF) 
+        if (char == '\r' && nextChar == '\n' && !inQuote) { 
+            col = 0; 
+            row++; 
+            index++; 
+            continue; 
+        }
+        
+        //New row if new line and not in quote (CR or LF) 
+        if ((char == '\r' || char == '\n') && !inQuote) { 
+            col = 0;
+            row++;
+            continue; 
+        }
 
-		this.eventMap = {
-			//row events
-			rowClick:"row-click",
-			rowDblClick:"row-dblclick",
-			rowContext:"row-contextmenu",
-			rowMouseEnter:"row-mouseenter",
-			rowMouseLeave:"row-mouseleave",
-			rowMouseOver:"row-mouseover",
-			rowMouseOut:"row-mouseout",
-			rowMouseMove:"row-mousemove",
-			rowTap:"row",
-			rowDblTap:"row",
-			rowTapHold:"row",
+        //Normal Character, append to column
+        data[row][col] += char;
+    }
 
-			//cell events
-			cellClick:"cell-click",
-			cellDblClick:"cell-dblclick",
-			cellContext:"cell-contextmenu",
-			cellMouseEnter:"cell-mouseenter",
-			cellMouseLeave:"cell-mouseleave",
-			cellMouseOver:"cell-mouseover",
-			cellMouseOut:"cell-mouseout",
-			cellMouseMove:"cell-mousemove",
-			cellTap:"cell",
-			cellDblTap:"cell",
-			cellTapHold:"cell",
+    return data;
+}
+
+function json$1(input){
+    try {
+        return JSON.parse(input);
+    } catch(e) {
+        console.warn("JSON Import Error - File contents is invalid JSON", e);
+        return Promise.reject();
+    }
+}
+
+var defaultImporters = {
+	csv:csvImporter,
+	json:json$1,
+};
+
+class Import extends Module{
+    
+    constructor(table){
+        super(table);
+        
+        this.registerTableOption("importFormat");
+        this.registerTableOption("importReader", "text");
+    }
+    
+    initialize(){
+        this.registerTableFunction("import", this.importFromFile.bind(this));
 
-			//column header events
-			headerClick:"column-click",
+        if(this.table.options.importFormat){
+            this.subscribe("data-loading", this.loadDataCheck.bind(this), 10);
+            this.subscribe("data-load", this.loadData.bind(this), 10);
+        }
+    }
+
+    loadDataCheck(data){
+        return typeof data === "string";
+    }
+
+    loadData(data, params, config, silent, previousData){
+        return this.importData(this.lookupImporter(), data)
+        .then(this.structureData.bind(this))
+        .catch((err) => {
+            console.error("Import Error:", err || "Unable to import data");
+            return Promise.reject(err);
+        })
+    }
+
+    lookupImporter(importFormat){
+        var importer;
+        
+        if(!importFormat){
+            importFormat = this.table.options.importFormat;
+        }
+        
+        if(typeof importFormat === "string"){
+            importer = Import.importers[importFormat];
+        }else {
+            importer = importFormat;
+        }
+
+        if(!importer){
+            console.error("Import Error - Importer not found:", importFormat);
+        }
+        
+        return importer;
+    }
+    
+    importFromFile(importFormat, extension){
+        var importer = this.lookupImporter(importFormat);
+        
+        if(importer){
+            return this.pickFile(extension)
+            .then(this.importData.bind(this, importer))
+            .then(this.structureData.bind(this))
+            .then(this.setData.bind(this))
+            .catch((err) => {
+                console.error("Import Error:", err || "Unable to import file");
+                return Promise.reject(err);
+            })
+        }
+    }
+    
+    pickFile(extensions){
+        return new Promise((resolve, reject) => {
+            var input = document.createElement("input");
+            input.type = "file";
+            input.accept = extensions;
+            
+            input.addEventListener("change", (e) => {
+                var file = input.files[0],
+                reader = new FileReader();
+                
+                switch(this.table.options.importReader){
+                    case "buffer":
+                        reader.readAsArrayBuffer(file);
+                    break;
+
+                    case "binary":
+                        reader.readAsBinaryString(file);
+                    break;
+
+                    case "url":
+                        reader.readAsDataURL(file);
+                    break;
+
+                    case "text":
+                    default:
+                        reader.readAsText(file);
+                }
+                  
+                reader.onload = (e) => {
+                    resolve(reader.result);
+                };
+                
+                reader.onerror = (e) => {
+                    console.warn("File Load Error - Unable to read file");
+                    reject();
+                };
+            });
+            
+            input.click();
+        });
+    }
+    
+    importData(importer, fileContents){
+        var data = importer.call(this.table, fileContents);
+        
+        if(data instanceof Promise){
+            return data;
+        }else {
+            return data ? Promise.resolve(data) : Promise.reject();
+        }
+    }
+
+    structureData(parsedData){
+        var data = [];
+
+        console.log("structure", parsedData);
+
+        if(Array.isArray(parsedData) && parsedData.length && Array.isArray(parsedData[0])){
+            if(this.table.options.autoColumns){
+                data = this.structureArrayToObject(parsedData);
+            }else {
+                data = this.structureArrayToColumns(parsedData);
+            }
+
+            return data;
+        }else {
+            return parsedData;
+        }
+    }
+
+    structureArrayToObject(parsedData){
+        var columns = parsedData.shift();
+
+        var data = parsedData.map((values) => {
+            var row = {};
+
+            columns.forEach((key, i) => {
+                row[key] = values[i];
+            });
+
+            return row;
+        });
+
+        return data;
+    }
+
+    structureArrayToColumns(parsedData){
+        var data = [],
+        columns = this.table.getColumns();
+
+        //remove first row if it is the column names
+        if(columns[0] && parsedData[0][0]){
+            if(columns[0].getDefinition().title === parsedData[0][0]){
+                parsedData.shift();
+            }
+        }
+        
+        //convert row arrays to objects
+        parsedData.forEach((rowData) => {
+            var row = {};
+
+            rowData.forEach((value, index) => {
+                var column = columns[index];
+
+                if(column){
+                    row[column.getField()] = value;
+                }
+            });
+
+            data.push(row);
+        });
+
+        return data;
+    }
+    
+    setData(data){
+        return this.table.setData(data);
+    }
+}
+
+Import.moduleName = "import";
+
+//load defaults
+Import.importers = defaultImporters;
+
+class Interaction extends Module{
+
+	constructor(table){
+		super(table);
+
+		this.eventMap = {
+			//row events
+			rowClick:"row-click",
+			rowDblClick:"row-dblclick",
+			rowContext:"row-contextmenu",
+			rowMouseEnter:"row-mouseenter",
+			rowMouseLeave:"row-mouseleave",
+			rowMouseOver:"row-mouseover",
+			rowMouseOut:"row-mouseout",
+			rowMouseMove:"row-mousemove",
+			rowTap:"row",
+			rowDblTap:"row",
+			rowTapHold:"row",
+
+			//cell events
+			cellClick:"cell-click",
+			cellDblClick:"cell-dblclick",
+			cellContext:"cell-contextmenu",
+			cellMouseEnter:"cell-mouseenter",
+			cellMouseLeave:"cell-mouseleave",
+			cellMouseOver:"cell-mouseover",
+			cellMouseOut:"cell-mouseout",
+			cellMouseMove:"cell-mousemove",
+			cellTap:"cell",
+			cellDblTap:"cell",
+			cellTapHold:"cell",
+
+			//column header events
+			headerClick:"column-click",
 			headerDblClick:"column-dblclick",
 			headerContext:"column-contextmenu",
 			headerMouseEnter:"column-mouseenter",
@@ -11959,6 +12238,11 @@ class Interaction extends Module{
 				tap:null,
 				tapDbl:null,
 				tapHold:null,
+			},
+			group:{
+				tap:null,
+				tapDbl:null,
+				tapHold:null,
 			}
 		};
 
@@ -12189,9 +12473,9 @@ var defaultBindings = {
 	scrollPageDown:34,
 	scrollToStart:36,
 	scrollToEnd:35,
-	undo:"ctrl + 90",
-	redo:"ctrl + 89",
-	copyToClipboard:"ctrl + 67",
+	undo:["ctrl + 90", "meta + 90"],
+	redo:["ctrl + 89", "meta + 89"],
+	copyToClipboard:["ctrl + 67", "meta + 89"],
 };
 
 var defaultActions = {
@@ -12325,7 +12609,7 @@ class Keybindings extends Module{
 		this.keyupBinding = false;
 		this.keydownBinding = false;
 
-		this.registerTableOption("keybindings", []); //array for keybindings
+		this.registerTableOption("keybindings", {}); //array for keybindings
 		this.registerTableOption("tabEndNewRow", false); //create new row when tab to end of table
 	}
 
@@ -12337,17 +12621,8 @@ class Keybindings extends Module{
 		this.pressedKeys = [];
 
 		if(bindings !== false){
-
-			for(let key in Keybindings.bindings){
-				mergedBindings[key] = Keybindings.bindings[key];
-			}
-
-			if(Object.keys(bindings).length){
-
-				for(let key in bindings){
-					mergedBindings[key] = bindings[key];
-				}
-			}
+			Object.assign(mergedBindings, Keybindings.bindings);
+			Object.assign(mergedBindings, bindings);
 
 			this.mapBindings(mergedBindings);
 			this.bindEvents();
@@ -12365,7 +12640,11 @@ class Keybindings extends Module{
 					}
 
 					bindings[key].forEach((binding) => {
-						this.mapBinding(key, binding);
+						var bindingList = Array.isArray(binding) ?  binding : [binding];
+						
+						bindingList.forEach((item) => {
+							this.mapBinding(key, item);
+						});						
 					});
 				}
 			}else {
@@ -12400,7 +12679,7 @@ class Keybindings extends Module{
 				break;
 
 				default:
-				symbol = parseInt(symbol);
+				symbol = isNaN(symbol) ? symbol.toUpperCase().charCodeAt(0) : parseInt(symbol);
 				binding.keys.push(symbol);
 
 				if(!this.watchKeys[symbol]){
@@ -12488,164 +12767,193 @@ Keybindings.bindings = defaultBindings;
 Keybindings.actions = defaultActions;
 
 class Menu extends Module{
-
+	
 	constructor(table){
 		super(table);
-
+		
+		this.menuContainer = null;
 		this.menuElements = [];
 		this.blurEvent = this.hideMenu.bind(this);
 		this.escEvent = this.escMenu.bind(this);
 		this.nestedMenuBlock = false;
 		this.positionReversedX = false;
-
+		
+		this.currentComponent = null;
+		
+		this.columnSubscribers = {};
+		
 		this.registerTableOption("rowContextMenu", false);
 		this.registerTableOption("rowClickMenu", false);
 		this.registerTableOption("groupContextMenu", false);
 		this.registerTableOption("groupClickMenu", false);
-
+		this.registerTableOption("menuContainer", false);
+		
 		this.registerColumnOption("headerContextMenu");
+		this.registerColumnOption("headerClickMenu");
 		this.registerColumnOption("headerMenu");
 		this.registerColumnOption("contextMenu");
 		this.registerColumnOption("clickMenu");
 	}
-
+	
 	initialize(){
-		this.subscribe("cell-layout", this.layoutCell.bind(this));
+		this.lookupMenuContainer();
+		
+		this.initializeRowWatchers();
+		this.initializeGroupWatchers();
+		
 		this.subscribe("column-init", this.initializeColumn.bind(this));
-		this.subscribe("row-init", this.initializeRow.bind(this));
 	}
-
-	layoutCell(cell){
-		if(cell.column.definition.contextMenu || cell.column.definition.clickMenu){
-			this.initializeCell(cell);
+	
+	lookupMenuContainer(){
+		
+		this.menuContainer = this.table.options.menuContainer;
+		
+		if(typeof this.menuContainer === "string"){
+			this.menuContainer = document.querySelector(this.menuContainer);
+			
+			if(!this.menuContainer){
+				console.warn("Menu Error - no container element found matching selector:",  this.table.options.menuContainer , "(defaulting to document body)");
+			}
+		}else if (this.menuContainer === true){
+			this.menuContainer = this.table.element;
+		}
+		
+		if(this.menuContainer && !this.checkMenuContainerIsParent(this.menuContainer)){
+			this.menuContainer = false;
+			console.warn("Menu Error - container element does not contain this table:",  this.table.options.menuContainer , "(defaulting to document body)");
+		}
+		
+		if(!this.menuContainer){
+			this.menuContainer = document.body;
+		}
+	}
+	
+	checkMenuContainerIsParent(container, element = this.table.element){
+		if(container === element){
+			return true;
+		}else {
+			return element.parentNode ? this.checkMenuContainerIsParent(container, element.parentNode) : false;
 		}
 	}
-
-	initializeColumn(column){
-		var def = column.definition;
-
-		if(def.headerContextMenu || def.headerClickMenu || def.headerMenu){
-			this.initializeColumnHeader(column);
+	
+	initializeRowWatchers(){
+		if(this.table.options.rowContextMenu){
+			this.subscribe("row-contextmenu", this.loadMenuEvent.bind(this, this.table.options.rowContextMenu));
+			this.table.on("rowTapHold", this.loadMenuEvent.bind(this, this.table.options.rowContextMenu));
+		}
+		
+		if(this.table.options.rowClickMenu){
+			this.subscribe("row-click", this.loadMenuEvent.bind(this, this.table.options.rowClickMenu));
 		}
 	}
-
-	initializeColumnHeader(column){
-		var headerMenuEl;
-
-		if(column.definition.headerContextMenu){
-			column.getElement().addEventListener("contextmenu", this.LoadMenuEvent.bind(this, column, column.definition.headerContextMenu));
-			this.tapHold(column, column.definition.headerContextMenu);
+	
+	initializeGroupWatchers(){
+		if(this.table.options.groupContextMenu){
+			this.subscribe("group-contextmenu", this.loadMenuEvent.bind(this, this.table.options.groupContextMenu));
+			this.table.on("groupTapHold", this.loadMenuEvent.bind(this, this.table.options.groupContextMenu));
 		}
-
-		// 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 = "&vellip;";
-
-			headerMenuEl.addEventListener("click", (e) => {
-				e.stopPropagation();
-				e.preventDefault();
-
-				this.LoadMenuEvent(column, column.definition.headerMenu, e);
-			});
-
-			column.titleElement.insertBefore(headerMenuEl, column.titleElement.firstChild);
+		
+		if(this.table.options.groupClickMenu){
+			this.subscribe("group-click", this.loadMenuEvent.bind(this, this.table.options.groupClickMenu));
 		}
 	}
-
-	LoadMenuEvent(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);
-	}
-
-	tapHold(component, menu){
-		var element = component.getElement(),
-		tapHold = null,
-		loaded = false;
-
-		element.addEventListener("touchstart", (e) => {
-			clearTimeout(tapHold);
-			loaded = false;
-
-			tapHold = setTimeout(() => {
-				clearTimeout(tapHold);
-				tapHold = null;
-				loaded = true;
-
-				this.LoadMenuEvent(component, menu, e);
-			}, 1000);
-
-		}, {passive: true});
-
-		element.addEventListener("touchend", (e) => {
-			clearTimeout(tapHold);
-			tapHold = null;
-
-			if(loaded){
-				e.preventDefault();
-			}
+	
+	initializeColumn(column){
+		var def = column.definition;
+		
+		//handle column events
+		if(def.headerContextMenu && !this.columnSubscribers.headerContextMenu){
+			this.columnSubscribers.headerContextMenu = this.loadMenuTableColumnEvent.bind(this, "headerContextMenu");
+			this.subscribe("column-contextmenu", this.columnSubscribers.headerContextMenu);
+			this.table.on("headerTapHold", this.loadMenuTableColumnEvent.bind(this, "headerContextMenu"));
+		}
+		
+		if(def.headerClickMenu && !this.columnSubscribers.headerClickMenu){
+			this.columnSubscribers.headerClickMenu = this.loadMenuTableColumnEvent.bind(this, "headerClickMenu");
+			this.subscribe("column-click", this.columnSubscribers.headerClickMenu);
+		}
+		
+		if(def.headerMenu){
+			this.initializeColumnHeaderMenu(column);
+		}
+		
+		//handle cell events
+		if(def.contextMenu && !this.columnSubscribers.contextMenu){
+			this.columnSubscribers.contextMenu = this.loadMenuTableCellEvent.bind(this, "contextMenu");
+			this.subscribe("cell-contextmenu", this.columnSubscribers.contextMenu);
+			this.table.on("cellTapHold", this.loadMenuTableCellEvent.bind(this, "contextMenu"));
+		}
+		
+		if(def.clickMenu && !this.columnSubscribers.clickMenu){
+			this.columnSubscribers.clickMenu = this.loadMenuTableCellEvent.bind(this, "clickMenu");
+			this.subscribe("cell-click", this.columnSubscribers.clickMenu);
+		}
+	}
+	
+	initializeColumnHeaderMenu(column){
+		var headerMenuEl;
+		
+		headerMenuEl = document.createElement("span");
+		headerMenuEl.classList.add("tabulator-header-menu-button");
+		headerMenuEl.innerHTML = "&vellip;";
+		
+		headerMenuEl.addEventListener("click", (e) => {
+			e.stopPropagation();
+			e.preventDefault();
+			
+			this.loadMenuEvent(column.definition.headerMenu, e, column);
 		});
+		
+		column.titleElement.insertBefore(headerMenuEl, column.titleElement.firstChild);
 	}
-
-	initializeCell(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);
+	
+	loadMenuTableCellEvent(option, e, cell){
+		if(cell._cell){
+			cell = cell._cell;
 		}
-
-		if(cell.column.definition.clickMenu){
-			cell.getElement(true).addEventListener("click", this.LoadMenuEvent.bind(this, cell, cell.column.definition.clickMenu));
+		
+		if(cell.column.definition[option]){
+			this.loadMenuEvent(cell.column.definition[option], e, cell);
 		}
 	}
-
-	initializeRow(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);
+	
+	loadMenuTableColumnEvent(option, e, column){
+		if(column._column){
+			column = column._column;
 		}
-
-		if(this.table.options.rowClickMenu){
-			row.getElement().addEventListener("click", this.LoadMenuEvent.bind(this, row, this.table.options.rowClickMenu));
+		
+		if(column.definition[option]){
+			this.loadMenuEvent(column.definition[option], e, column);
 		}
 	}
-
-	initializeGroup (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));
+	
+	loadMenuEvent(menu, e, component){
+		if(component._group){
+			component = component._group;
+		}else if(component._row){
+			component = component._row;
 		}
+		
+		menu = typeof menu == "function" ? menu.call(this.table, component.getComponent(), e) : menu;
+		
+		this.loadMenu(e, component, menu);
 	}
-
+	
 	loadMenu(e, component, menu, parentEl){
-
 		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
@@ -12657,35 +12965,35 @@ class Menu extends Module{
 					this.nestedMenuBlock = false;
 				}, 100);
 			}
-
+			
 			this.hideMenu();
 			this.menuElements = [];
 		}
-
+		
 		menu.forEach((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(this.table, component.getComponent());
 				}
-
+				
 				if(label instanceof Node){
 					itemEl.appendChild(label);
 				}else {
 					itemEl.innerHTML = label;
 				}
-
+				
 				if(typeof disabled == "function"){
 					disabled = disabled.call(this.table, component.getComponent());
 				}
-
+				
 				if(disabled){
 					itemEl.classList.add("tabulator-menu-item-disabled");
 					itemEl.addEventListener("click", (e) => {
@@ -12706,57 +13014,67 @@ class Menu extends Module{
 						}
 					}
 				}
-
+				
 				if(item.menu && item.menu.length){
 					itemEl.classList.add("tabulator-menu-item-submenu");
 				}
 			}
-
+			
 			menuEl.appendChild(itemEl);
 		});
-
+		
 		menuEl.addEventListener("click", (e) => {
 			this.hideMenu();
 		});
-
+		
 		this.menuElements.push(menuEl);
 		this.positionMenu(menuEl, parentEl, touch, e);
+		
+		this.currentComponent = component;
+		
+		this.dispatchExternal("menuOpened", component.getComponent());
 	}
-
+	
 	hideOldSubMenus(menuEl){
 		var index = this.menuElements.indexOf(menuEl);
-
+		
 		if(index > -1){
 			for(let i = this.menuElements.length - 1; i > index; i--){
 				var el = this.menuElements[i];
-
+				
 				if(el.parentNode){
 					el.parentNode.removeChild(el);
 				}
-
+				
 				this.menuElements.pop();
 			}
 		}
 	}
-
+	
 	positionMenu(element, parentEl, touch, e){
-		var docHeight = Math.max(document.body.offsetHeight, window.innerHeight),
-		x, y, parentOffset;
-
+		var x, y, parentOffset;
+		
 		if(!parentEl){
 			x = touch ? e.touches[0].pageX : e.pageX;
 			y = touch ? e.touches[0].pageY : e.pageY;
-
+			
+			if(this.menuContainer !== document.body){
+				parentOffset = Helpers.elOffset(this.menuContainer);
+				
+				x -= parentOffset.left;
+				y -= parentOffset.top;
+			}
+			
 			this.positionReversedX = false;
 		}else {
 			parentOffset = Helpers.elOffset(parentEl);
 			x = parentOffset.left + parentEl.offsetWidth;
 			y = parentOffset.top - 1;
 		}
-
+		
 		element.style.top = y + "px";
 		element.style.left = x + "px";
-
+		
 		setTimeout(() => {
 			this.table.rowManager.element.addEventListener("scroll", this.blurEvent);
 			document.body.addEventListener("click", this.blurEvent);
@@ -12764,66 +13082,71 @@ class Menu extends Module{
 			window.addEventListener("resize", this.blurEvent);
 			document.body.addEventListener("keydown", this.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 = "";
-
+		
+		this.menuContainer.appendChild(element);
+		
+		//move menu to start on right edge if it is too close to the edge of the screen
+		if((x + element.offsetWidth) >= this.menuContainer.offsetWidth || this.positionReversedX){
+			element.style.left = "";
+			
 			if(parentEl){
-				element.style.bottom = (docHeight - parentOffset.top - parentEl.offsetHeight - 1) + "px";
+				element.style.right = (this.menuContainer.offsetWidth - parentOffset.left) + "px";
 			}else {
-				element.style.bottom = (docHeight - y) + "px";
+				element.style.right = (this.menuContainer.offsetWidth - x) + "px";
 			}
+			
+			this.positionReversedX = true;
 		}
-
-		//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 = "";
-
+		
+		//move menu to start on bottom edge if it is too close to the edge of the screen
+		if((y + element.offsetHeight) >= this.menuContainer.offsetHeight){
+			element.style.top = "";
+			
 			if(parentEl){
-				element.style.right = (document.documentElement.offsetWidth - parentOffset.left) + "px";
+				element.style.bottom = (this.menuContainer.offsetHeight - parentOffset.top - parentEl.offsetHeight - 1) + "px";
 			}else {
-				element.style.right = (document.documentElement.offsetWidth - x) + "px";
+				element.style.bottom = (this.menuContainer.offsetHeight - y) + "px";
 			}
-
-			this.positionReversedX = true;
 		}
 	}
-
+	
 	isOpen(){
 		return !!this.menuElements.length;
 	}
-
+	
 	escMenu(e){
 		if(e.keyCode == 27){
 			this.hideMenu();
 		}
 	}
-
-	hideMenu(){
+	
+	hideMenu(){	
 		this.menuElements.forEach((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);
+		
+		if(this.currentComponent){
+			this.dispatchExternal("menuClosed", this.currentComponent.getComponent());
+			this.currentComponent = null;
+		}
 	}
 }
 
 Menu.moduleName = "menu";
 
 class MoveColumns extends Module{
-
+	
 	constructor(table){
 		super(table);
-
+		
 		this.placeholderElement = this.createPlaceholderElement();
 		this.hoverElement = false; //floating column header element
 		this.checkTimeout = false; //click check timeout holder
@@ -12836,35 +13159,36 @@ class MoveColumns extends Module{
 		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);
-
+		
 		this.registerTableOption("movableColumns", false); //enable movable columns
 	}
-
+	
 	createPlaceholderElement(){
 		var el = document.createElement("div");
-
+		
 		el.classList.add("tabulator-col");
 		el.classList.add("tabulator-col-placeholder");
-
+		
 		return el;
 	}
-
+	
 	initialize(){
-		this.subscribe("column-init", this.initializeColumn.bind(this));
+		if(this.table.options.movableColumns){
+			this.subscribe("column-init", this.initializeColumn.bind(this));
+		}
 	}
-
+	
 	initializeColumn(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) - Helpers.elOffset(colEl).left) + self.table.columnManager.element.scrollLeft) > (column.getWidth() / 2)){
@@ -12880,7 +13204,7 @@ class MoveColumns extends Module{
 					}
 				}
 			}.bind(self);
-
+			
 			colEl.addEventListener("mousedown", function(e){
 				self.touchMove = false;
 				if(e.which === 1){
@@ -12889,7 +13213,7 @@ class MoveColumns extends Module{
 					}, self.checkPeriod);
 				}
 			});
-
+			
 			colEl.addEventListener("mouseup", function(e){
 				if(e.which === 1){
 					if(self.checkTimeout){
@@ -12897,18 +13221,18 @@ class MoveColumns extends Module{
 					}
 				}
 			});
-
+			
 			self.bindTouchEvents(column);
 		}
-
+		
 		column.modules.moveColumn = config;
 	}
-
+	
 	bindTouchEvents(column){
 		var colEl = column.getElement(),
 		startXMove = false, //shifting center position of the cell
 		nextCol, prevCol, nextColWidth, prevColWidth, nextColWidthLast, prevColWidthLast;
-
+		
 		colEl.addEventListener("touchstart", (e) => {
 			this.checkTimeout = setTimeout(() => {
 				this.touchMove = true;
@@ -12919,27 +13243,27 @@ class MoveColumns extends Module{
 				nextColWidthLast = 0;
 				prevColWidthLast = 0;
 				startXMove = false;
-
+				
 				this.startMove(e, column);
 			}, this.checkPeriod);
 		}, {passive: true});
-
+		
 		colEl.addEventListener("touchmove", (e) => {
 			var diff, moveToCol;
-
+			
 			if(this.moving){
 				this.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(this.placeholderElement, moveToCol.getElement().nextSibling);
@@ -12949,7 +13273,7 @@ class MoveColumns extends Module{
 				}else {
 					if(prevCol && -diff - prevColWidthLast >  prevColWidth){
 						moveToCol = prevCol;
-
+						
 						if(moveToCol !== column){
 							startXMove = e.touches[0].pageX;
 							moveToCol.getElement().parentNode.insertBefore(this.placeholderElement, moveToCol.getElement());
@@ -12957,7 +13281,7 @@ class MoveColumns extends Module{
 						}
 					}
 				}
-
+				
 				if(moveToCol){
 					nextCol = moveToCol.nextColumn();
 					nextColWidthLast = nextColWidth;
@@ -12968,7 +13292,7 @@ class MoveColumns extends Module{
 				}
 			}
 		}, {passive: true});
-
+		
 		colEl.addEventListener("touchend", (e) => {
 			if(this.checkTimeout){
 				clearTimeout(this.checkTimeout);
@@ -12978,43 +13302,43 @@ class MoveColumns extends Module{
 			}
 		});
 	}
-
+	
 	startMove(e, column){
 		var element = column.getElement(),
 		headerElement = this.table.columnManager.getElement(),
 		headersElement = this.table.columnManager.getHeadersElement();
-
+		
 		this.moving = column;
 		this.startX = (this.touchMove ? e.touches[0].pageX : e.pageX) - 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 = (headerElement.clientHeight - headersElement.offsetHeight) + "px";
-
+		
 		if(!this.touchMove){
 			this._bindMouseMove();
-
+			
 			document.body.addEventListener("mousemove", this.moveHover);
 			document.body.addEventListener("mouseup", this.endMove);
 		}
-
+		
 		this.moveHover(e);
 	}
-
+	
 	_bindMouseMove(){
 		this.table.columnManager.columnsByIndex.forEach(function(column){
 			if(column.modules.moveColumn.mousemove){
@@ -13022,7 +13346,7 @@ class MoveColumns extends Module{
 			}
 		});
 	}
-
+	
 	_unbindMouseMove(){
 		this.table.columnManager.columnsByIndex.forEach(function(column){
 			if(column.modules.moveColumn.mousemove){
@@ -13030,17 +13354,17 @@ class MoveColumns extends Module{
 			}
 		});
 	}
-
+	
 	moveColumn(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);
-
+				
 				if(cellEl.parentNode && movingCells[i]){
 					cellEl.parentNode.insertBefore(movingCells[i].getElement(), cellEl.nextSibling);
 				}
@@ -13048,47 +13372,47 @@ class MoveColumns extends Module{
 		}else {
 			column.getCells().forEach(function(cell, i){
 				var cellEl = cell.getElement(true);
-
+				
 				if(cellEl.parentNode && movingCells[i]){
 					cellEl.parentNode.insertBefore(movingCells[i].getElement(), cellEl);
 				}
 			});
 		}
 	}
-
+	
 	endMove(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);
 			}
 		}
 	}
-
+	
 	moveHover(e){
 		var columnHolder = this.table.columnManager.getElement(),
 		scrollLeft = columnHolder.scrollLeft,
 		xPos = ((this.touchMove ? e.touches[0].pageX : e.pageX) - Helpers.elOffset(columnHolder).left) + scrollLeft,
 		scrollPos;
-
+		
 		this.hoverElement.style.left = (xPos - this.startX) + "px";
-
+		
 		if(xPos - scrollLeft < this.autoScrollMargin){
 			if(!this.autoScrollTimeout){
 				this.autoScrollTimeout = setTimeout(() => {
@@ -13098,7 +13422,7 @@ class MoveColumns extends Module{
 				}, 1);
 			}
 		}
-
+		
 		if(scrollLeft + columnHolder.clientWidth - xPos < this.autoScrollMargin){
 			if(!this.autoScrollTimeout){
 				this.autoScrollTimeout = setTimeout(() => {
@@ -13430,6 +13754,8 @@ class MoveRows extends Module{
 		document.body.addEventListener("mousemove", this.moveHover);
 		document.body.addEventListener("mouseup", this.endMove);
 
+		this.dispatchExternal("rowMoving", row.getComponent());
+
 		this.moveHover(e);
 	}
 
@@ -13464,6 +13790,8 @@ class MoveRows extends Module{
 
 			if(this.toRow){
 				this.table.rowManager.moveRow(this.moving, this.toRow, this.toRowAfter);
+			}else {
+				this.dispatchExternal("rowMoveCancelled", this.moving.getComponent());
 			}
 
 			this.moving = false;
@@ -13878,44 +14206,121 @@ Mutator.moduleName = "mutator";
 //load defaults
 Mutator.mutators = defaultMutators;
 
+function rows(pageSize, currentRow, currentPage, totalRows, totalPages){
+	var el = document.createElement("span"),
+	showingEl = document.createElement("span"),
+	valueEl = document.createElement("span"),
+	ofEl = document.createElement("span"),
+	totalEl = document.createElement("span"),
+	rowsEl = document.createElement("span");
+	
+	this.table.modules.localize.langBind("pagination|counter|showing", (value) => {
+		showingEl.innerHTML = value;
+	});
+	
+	valueEl.innerHTML = " " + currentRow + "-" + Math.min((currentRow + pageSize - 1), totalRows) + " ";
+	
+	this.table.modules.localize.langBind("pagination|counter|of", (value) => {
+		ofEl.innerHTML = value;
+	});
+	
+	totalEl.innerHTML = " " + totalRows + " ";
+	
+	this.table.modules.localize.langBind("pagination|counter|rows", (value) => {
+		rowsEl.innerHTML = value;
+	});
+	
+	el.appendChild(showingEl);
+	el.appendChild(valueEl);
+	el.appendChild(ofEl);
+	el.appendChild(totalEl);
+	el.appendChild(rowsEl);
+	
+	return el;
+}
+
+function pages(pageSize, currentRow, currentPage, totalRows, totalPages){
+
+    var el = document.createElement("span"),
+	showingEl = document.createElement("span"),
+	valueEl = document.createElement("span"),
+	ofEl = document.createElement("span"),
+	totalEl = document.createElement("span"),
+	rowsEl = document.createElement("span");
+	
+	this.table.modules.localize.langBind("pagination|counter|showing", (value) => {
+		showingEl.innerHTML = value;
+	});
+	
+	valueEl.innerHTML = " " + currentPage + " ";
+	
+	this.table.modules.localize.langBind("pagination|counter|of", (value) => {
+		ofEl.innerHTML = value;
+	});
+	
+	totalEl.innerHTML = " " + totalPages + " ";
+	
+	this.table.modules.localize.langBind("pagination|counter|pages", (value) => {
+		rowsEl.innerHTML = value;
+	});
+	
+	el.appendChild(showingEl);
+	el.appendChild(valueEl);
+	el.appendChild(ofEl);
+	el.appendChild(totalEl);
+	el.appendChild(rowsEl);
+	
+	return el;
+}
+
+var defaultPageCounters = {
+	rows:rows,
+	pages:pages,
+};
+
 class Page extends Module{
-
+	
 	constructor(table){
 		super(table);
-
+		
 		this.mode = "local";
 		this.progressiveLoad = false;
-
+		
+		this.element = null;
+		this.pageCounterElement = null;
+		this.pageCounter = null;
+		
 		this.size = 0;
 		this.page = 1;
 		this.count = 5;
 		this.max = 1;
 
+		this.remoteRowCountEstimate = null;
+		
 		this.displayIndex = 0; //index in display pipeline
-
+		
 		this.initialLoad = true;
 		this.dataChanging = false; //flag to check if data is being changed by this module
-
+		
 		this.pageSizes = [];
-
-		this.dataReceivedNames = {}; //TODO - remove once pagimation update is complete
-		this.dataSentNames = {}; //TODO - remove once pagimation update is complete
-
+		
 		this.registerTableOption("pagination", false); //set pagination type
 		this.registerTableOption("paginationMode", "local"); //local or remote pagination
 		this.registerTableOption("paginationSize", false); //set number of rows to a page
-		this.registerTableOption("paginationInitialPage", 1); //initail page to show on load
+		this.registerTableOption("paginationInitialPage", 1); //initial page to show on load
+		this.registerTableOption("paginationCounter", false);  // set pagination counter
+		this.registerTableOption("paginationCounterElement", false);  // set pagination counter
 		this.registerTableOption("paginationButtonCount", 5);  // set count of page button
 		this.registerTableOption("paginationSizeSelector", false); //add pagination size selector element
 		this.registerTableOption("paginationElement", false); //element to hold pagination numbers
 		// this.registerTableOption("paginationDataSent", {}); //pagination data sent to the server
 		// this.registerTableOption("paginationDataReceived", {}); //pagination data received from the server
 		this.registerTableOption("paginationAddRow", "page"); //add rows on table or page
-
+		
 		this.registerTableOption("progressiveLoad", false); //progressive loading
 		this.registerTableOption("progressiveLoadDelay", 0); //delay between requests
 		this.registerTableOption("progressiveLoadScrollMargin", 0); //margin before scroll begins
-
+		
 		this.registerTableFunction("setMaxPage", this.setMaxPage.bind(this));
 		this.registerTableFunction("setPage", this.setPage.bind(this));
 		this.registerTableFunction("setPageToRow", this.userSetPageToRow.bind(this));
@@ -13925,11 +14330,11 @@ class Page extends Module{
 		this.registerTableFunction("nextPage", this.nextPage.bind(this));
 		this.registerTableFunction("getPage", this.getPage.bind(this));
 		this.registerTableFunction("getPageMax", this.getPageMax.bind(this));
-
+		
 		//register component functions
 		this.registerComponentFunction("row", "pageTo", this.setPageToRow.bind(this));
 	}
-
+	
 	initialize(){
 		if(this.table.options.pagination){
 			this.subscribe("row-deleted", this.rowsUpdated.bind(this));
@@ -13937,40 +14342,41 @@ class Page extends Module{
 			this.subscribe("row-added", this.rowsUpdated.bind(this));
 			this.subscribe("data-processed", this.initialLoadComplete.bind(this));
 			this.subscribe("table-built", this.calculatePageSizes.bind(this));
-
+			
 			if(this.table.options.paginationMode === "remote"){
 				this.subscribe("data-params", this.remotePageParams.bind(this));
 				this.subscribe("data-loaded", this._parseRemoteData.bind(this));
 			}
-
+			
 			if(this.table.options.progressiveLoad){
 				console.error("Progressive Load Error - Pagination and progressive load cannot be used at the same time");
 			}
-
+			
 			this.registerDisplayHandler(this.restOnRenderBefore.bind(this), 40);
 			this.registerDisplayHandler(this.getRows.bind(this), 50);
-
+			
 			this.createElements();
+			this.initializePageCounter();
 			this.initializePaginator();
 		}else if(this.table.options.progressiveLoad){
-
 			this.subscribe("data-params", this.remotePageParams.bind(this));
 			this.subscribe("data-loaded", this._parseRemoteData.bind(this));
 			this.subscribe("table-built", this.calculatePageSizes.bind(this));
-
+			this.subscribe("data-processed", this.initialLoadComplete.bind(this));
+			
 			this.initializeProgressive(this.table.options.progressiveLoad);
-
+			
 			if(this.table.options.progressiveLoad === "scroll"){
 				this.subscribe("scroll-vertical", this.scrollVertical.bind(this));
 			}
 		}
 	}
-
+	
 	rowAddingPosition(row, top){
 		var rowManager = this.table.rowManager,
 		dispRows = rowManager.getDisplayRows(),
 		index;
-
+		
 		if(top){
 			if(dispRows.length){
 				index = dispRows[0];
@@ -13986,74 +14392,74 @@ class Page extends Module{
 				top = dispRows.length < this.size ? false : true;
 			}
 		}
-
+		
 		return {index, top}
 	}
-
+	
 	calculatePageSizes(){
 		var testElRow, testElCell;
-
+		
 		if(this.table.options.paginationSize){
 			this.size = this.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);
-
+			
 			this.table.rowManager.getTableElement().appendChild(testElRow);
-
+			
 			this.size = Math.floor(this.table.rowManager.getElement().clientHeight / testElRow.offsetHeight);
-
+			
 			this.table.rowManager.getTableElement().removeChild(testElRow);
 		}
-
+		
 		this.generatePageSizeSelectList();
 	}
-
+	
 	initialLoadComplete(){
 		this.initialLoad = false;
 	}
-
+	
 	remotePageParams(data, config, silent, params){
 		if(!this.initialLoad){
 			if((this.progressiveLoad && !silent) || (!this.progressiveLoad && !this.dataChanging)){
 				this.reset(true);
 			}
 		}
-
+		
 		//configure request params
 		params.page = this.page;
-
+		
 		//set page size if defined
 		if(this.size){
 			params.size = this.size;
 		}
-
+		
 		return params;
 	}
-
+	
 	///////////////////////////////////
 	///////// Table Functions /////////
 	///////////////////////////////////
-
+	
 	userSetPageToRow(row){
 		if(this.table.options.pagination){
 			row = this.rowManager.findRow(row);
-
+			
 			if(row){
 				return this.setPageToRow(row)
 			}
 		}
-
+		
 		return Promise.reject();
 	}
-
+	
 	userSetPageSize(size){
 		if(this.table.options.pagination){
 			this.setPageSize(size);
@@ -14065,101 +14471,102 @@ class Page extends Module{
 	///////////////////////////////////
 	///////// Internal Logic //////////
 	///////////////////////////////////
-
+	
 	scrollVertical(top, dir){
 		var element, diff, margin;
 		if(!dir && !this.table.dataLoader.loading){
 			element = this.table.rowManager.getElement();
 			diff = element.scrollHeight - element.clientHeight - top;
 			margin = this.table.options.progressiveLoadScrollMargin || (element.clientHeight * 2);
-
+			
 			if(diff < margin){
-				this.nextPage();
+				this.nextPage()
+				.catch(() => {}); //consume the exception thrown when on the last page
 			}
 		}
 	}
-
+	
 	restOnRenderBefore(rows, renderInPosition){
 		if(!renderInPosition){
 			if(this.mode === "local"){
 				this.reset();
 			}
 		}
-
+		
 		return rows;
 	}
-
+	
 	rowsUpdated(){
 		this.refreshData(true, "all");
 	}
-
+	
 	createElements(){
 		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");
 		}
 	}
-
+	
 	generatePageSizeSelectList(){
 		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 (let 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((item) => {
 				var itemEl = document.createElement("option");
 				itemEl.value = item;
-
+				
 				if(item === true){
 					this.langBind("pagination|all", function(value){
 						itemEl.innerHTML = value;
@@ -14167,136 +14574,178 @@ class Page extends Module{
 				}else {
 					itemEl.innerHTML = item;
 				}
-
-
-
+				
+				
+				
 				this.pageSizeSelect.appendChild(itemEl);
 			});
-
+			
 			this.pageSizeSelect.value = this.size;
 		}
 	}
-
-	//setup pageination
+	
+	initializePageCounter(){
+		var counter = this.table.options.paginationCounter,
+		pageCounter = null;
+		
+		if(counter){
+			if(typeof counter === "function"){
+				pageCounter = counter;
+			}else {
+				pageCounter = Page.pageCounters[counter];
+			}
+			
+			if(pageCounter){
+				this.pageCounter = pageCounter;
+				
+				this.pageCounterElement = document.createElement("span");
+				this.pageCounterElement.classList.add("tabulator-page-counter");
+			}else {
+				console.warn("Pagination Error - No such page counter found: ", counter);
+			}
+		}
+	}
+	
+	//setup pagination
 	initializePaginator(hidden){
-		var pageSelectLabel;
-
+		var pageSelectLabel, paginationCounterHolder;
+		
 		if(!hidden){
 			//build pagination element
-
+			
 			//bind localizations
 			this.langBind("pagination|first", (value) => {
 				this.firstBut.innerHTML = value;
 			});
-
+			
 			this.langBind("pagination|first_title", (value) => {
 				this.firstBut.setAttribute("aria-label", value);
 				this.firstBut.setAttribute("title", value);
 			});
-
+			
 			this.langBind("pagination|prev", (value) => {
 				this.prevBut.innerHTML = value;
 			});
-
+			
 			this.langBind("pagination|prev_title", (value) => {
 				this.prevBut.setAttribute("aria-label", value);
 				this.prevBut.setAttribute("title", value);
 			});
-
+			
 			this.langBind("pagination|next", (value) => {
 				this.nextBut.innerHTML = value;
 			});
-
+			
 			this.langBind("pagination|next_title", (value) => {
 				this.nextBut.setAttribute("aria-label", value);
 				this.nextBut.setAttribute("title", value);
 			});
-
+			
 			this.langBind("pagination|last", (value) => {
 				this.lastBut.innerHTML = value;
 			});
-
+			
 			this.langBind("pagination|last_title", (value) => {
 				this.lastBut.setAttribute("aria-label", value);
 				this.lastBut.setAttribute("title", value);
 			});
-
+			
 			//click bindings
 			this.firstBut.addEventListener("click", () => {
 				this.setPage(1);
 			});
-
+			
 			this.prevBut.addEventListener("click", () => {
 				this.previousPage();
 			});
-
+			
 			this.nextBut.addEventListener("click", () => {
 				this.nextPage();
 			});
-
+			
 			this.lastBut.addEventListener("click", () => {
 				this.setPage(this.max);
 			});
-
+			
 			if(this.table.options.paginationElement){
 				this.element = this.table.options.paginationElement;
 			}
-
+			
 			if(this.pageSizeSelect){
 				pageSelectLabel = document.createElement("label");
-
+				
 				this.langBind("pagination|page_size", (value) => {
 					this.pageSizeSelect.setAttribute("aria-label", value);
 					this.pageSizeSelect.setAttribute("title", value);
 					pageSelectLabel.innerHTML = value;
 				});
-
+				
 				this.element.appendChild(pageSelectLabel);
 				this.element.appendChild(this.pageSizeSelect);
-
+				
 				this.pageSizeSelect.addEventListener("change", (e) => {
 					this.setPageSize(this.pageSizeSelect.value == "true" ? true : this.pageSizeSelect.value);
 					this.setPage(1);
 				});
 			}
-
+			
 			//append to DOM
 			this.element.appendChild(this.firstBut);
 			this.element.appendChild(this.prevBut);
 			this.element.appendChild(this.pagesElement);
 			this.element.appendChild(this.nextBut);
 			this.element.appendChild(this.lastBut);
-
+			
 			if(!this.table.options.paginationElement && !hidden){
+				if(this.table.options.paginationCounter){
+
+					if(this.table.options.paginationCounterElement){
+						if(this.table.options.paginationCounterElement instanceof HTMLElement){
+							this.table.options.paginationCounterElement.appendChild(this.pageCounterElement);
+						}else if(typeof this.table.options.paginationCounterElement === "string"){
+							paginationCounterHolder = document.querySelector(this.table.options.paginationCounterElement);
+							
+							if(paginationCounterHolder){
+								paginationCounterHolder.appendChild(this.pageCounterElement);
+							}else {
+								console.warn("Pagination Error - Unable to find element matching paginationCounterElement selector:", this.table.options.paginationCounterElement);
+							}
+						}
+					}else {
+						this.table.footerManager.append(this.pageCounterElement);
+					}
+					
+				}
+				
 				this.table.footerManager.append(this.element, this);
 			}
-
+			
 			this.page = this.table.options.paginationInitialPage;
 			this.count = this.table.options.paginationButtonCount;
 		}
-
+		
 		//set default values
 		this.mode = this.table.options.paginationMode;
 	}
-
+	
 	initializeProgressive(mode){
 		this.initializePaginator(true);
 		this.mode = "progressive_" + mode;
 		this.progressiveLoad = true;
 	}
-
+	
 	trackChanges(){
 		this.dispatch("page-changed");
 	}
-
+	
 	setDisplayIndex(index){
 		this.displayIndex = index;
 	}
-
+	
 	getDisplayIndex(){
 		return this.displayIndex;
 	}
-
+	
 	//calculate maximum page from number of rows
 	setMaxRows(rowCount){
 		if(!rowCount){
@@ -14304,12 +14753,12 @@ class Page extends Module{
 		}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
 	reset(force){
 		if(!this.initialLoad){
@@ -14318,91 +14767,128 @@ class Page extends Module{
 			}
 		}
 	}
-
-	//set the maxmum page
+	
+	//set the maximum page
 	setMaxPage(max){
-
+		
 		max = parseInt(max);
-
+		
 		this.max = max || 1;
-
+		
 		if(this.page > this.max){
 			this.page = this.max;
 			this.trigger();
 		}
 	}
-
+	
 	//set current page number
 	setPage(page){
 		switch(page){
 			case "first":
 			return this.setPage(1);
-
+			
 			case "prev":
 			return this.previousPage();
-
+			
 			case "next":
 			return this.nextPage();
-
+			
 			case "last":
 			return this.setPage(this.max);
 		}
-
-
+		
 		page = parseInt(page);
-
+		
 		if((page > 0 && page <= this.max) || this.mode !== "local"){
 			this.page = page;
-
+			
 			this.trackChanges();
-
+			
 			return this.trigger();
 		}else {
 			console.warn("Pagination Error - Requested page is out of range of 1 - " + this.max + ":", page);
 			return Promise.reject();
 		}
 	}
-
+	
 	setPageToRow(row){
 		var rows = this.table.rowManager.getDisplayRows(this.displayIndex - 1);
 		var index = rows.indexOf(row);
-
+		
 		if(index > -1){
 			var page = this.size === true ? 1 : Math.ceil((index + 1) / this.size);
-
+			
 			return this.setPage(page)
 		}else {
 			console.warn("Pagination Error - Requested row is not visible");
 			return Promise.reject();
 		}
 	}
-
+	
 	setPageSize(size){
 		if(size !== true){
 			size = parseInt(size);
 		}
-
+		
 		if(size > 0){
 			this.size = size;
 		}
-
+		
 		if(this.pageSizeSelect){
 			// this.pageSizeSelect.value = size;
 			this.generatePageSizeSelectList();
 		}
-
+		
 		this.trackChanges();
 	}
+	
+	_setPageCounter(totalRows){
+		var content, currentRow;
+		
+		if(this.pageCounter){
+			currentRow = ((this.page - 1) * this.size) + 1;
+
+			if(this.mode === "remote"){
+				totalRows = this.remoteRowCountEstimate;
+			}
 
+			content = this.pageCounter.call(this, this.size, currentRow, this.page, totalRows, this.max);
+			
+			switch(typeof content){
+				case "object":
+				if(content instanceof Node){
+					
+					//clear previous cell contents
+					while(this.pageCounterElement.firstChild) this.pageCounterElement.removeChild(this.pageCounterElement.firstChild);
+					
+					this.pageCounterElement.appendChild(content);
+				}else {
+					this.pageCounterElement.innerHTML = "";
+					
+					if(content != null){
+						console.warn("Page Counter Error - Page Counter has returned a type of object, the only valid page counter object return is an instance of Node, the page counter returned:", content);
+					}
+				}
+				break;
+				case "undefined":
+				case "null":
+				this.pageCounterElement.innerHTML = "";
+				break;
+				default:
+				this.pageCounterElement.innerHTML = content;
+			}
+		}
+	}
+	
 	//setup the pagination buttons
 	_setPageButtons(){
 		let leftSize = Math.floor((this.count-1) / 2);
 		let rightSize = Math.ceil((this.count-1) / 2);
 		let min = this.max - this.page + leftSize + 1 < this.count ? this.max-this.count+1: Math.max(this.page-leftSize,1);
 		let max = this.page <= rightSize? Math.min(this.count, this.max) :Math.min(this.page+rightSize, this.max);
-
+		
 		while(this.pagesElement.firstChild) this.pagesElement.removeChild(this.pagesElement.firstChild);
-
+		
 		if(this.page == 1){
 			this.firstBut.disabled = true;
 			this.prevBut.disabled = true;
@@ -14410,7 +14896,7 @@ class Page extends Module{
 			this.firstBut.disabled = false;
 			this.prevBut.disabled = false;
 		}
-
+		
 		if(this.page == this.max){
 			this.lastBut.disabled = true;
 			this.nextBut.disabled = true;
@@ -14418,66 +14904,66 @@ class Page extends Module{
 			this.lastBut.disabled = false;
 			this.nextBut.disabled = false;
 		}
-
+		
 		for(let i = min; i <= max; i++){
 			if(i>0 && i <= this.max){
 				this.pagesElement.appendChild(this._generatePageButton(i));
 			}
 		}
-
+		
 		this.footerRedraw();
 	}
-
+	
 	_generatePageButton(page){
 		var button = document.createElement("button");
-
+		
 		button.classList.add("tabulator-page");
 		if(page == this.page){
 			button.classList.add("active");
 		}
-
+		
 		button.setAttribute("type", "button");
 		button.setAttribute("role", "button");
-
+		
 		this.langBind("pagination|page_title", (value) => {
 			button.setAttribute("aria-label", value + " " + page);
 			button.setAttribute("title", value + " " + page);
 		});
-
+		
 		button.setAttribute("data-page", page);
 		button.textContent = page;
-
+		
 		button.addEventListener("click", (e) => {
 			this.setPage(page);
 		});
-
+		
 		return button;
 	}
-
+	
 	//previous page
 	previousPage(){
 		if(this.page > 1){
 			this.page--;
-
+			
 			this.trackChanges();
-
+			
 			return this.trigger()
-
+			
 		}else {
 			console.warn("Pagination Error - Previous page would be less than page 1:", 0);
 			return Promise.reject();
 		}
 	}
-
+	
 	//next page
 	nextPage(){
 		if(this.page < this.max){
 			this.page++;
-
+			
 			this.trackChanges();
-
+			
 			return this.trigger();
-
+			
 		}else {
 			if(!this.progressiveLoad){
 				console.warn("Pagination Error - Next page would be greater than maximum page of " + this.max + ":", this.max + 1);
@@ -14485,34 +14971,34 @@ class Page extends Module{
 			return Promise.reject();
 		}
 	}
-
+	
 	//return current page number
 	getPage(){
 		return this.page;
 	}
-
+	
 	//return max page number
 	getPageMax(){
 		return this.max;
 	}
-
+	
 	getPageSize(size){
 		return this.size;
 	}
-
+	
 	getMode(){
 		return this.mode;
 	}
-
+	
 	//return appropriate rows for current page
 	getRows(data){
 		var output, start, end;
-
+		
 		if(this.mode == "local"){
 			output = [];
-
+			
 			this.setMaxRows(data.length);
-
+			
 			if(this.size === true){
 				start = 0;
 				end = data.length;
@@ -14520,89 +15006,94 @@ class Page extends Module{
 				start = this.size * (this.page - 1);
 				end = start + parseInt(this.size);
 			}
-
-
+			
+			
 			this._setPageButtons();
-
+			
 			for(let i = start; i < end; i++){
 				if(data[i]){
 					output.push(data[i]);
 				}
 			}
 
+			this._setPageCounter(data.length);
+			
 			return output;
 		}else {
 			this._setPageButtons();
-
+			this._setPageCounter(data.length);
+			
 			return data.slice(0);
 		}
 	}
-
+	
 	trigger(){
 		var left;
-
+		
 		switch(this.mode){
 			case "local":
 			left = this.table.rowManager.scrollLeft;
-
+			
 			this.refreshData();
 			this.table.rowManager.scrollHorizontal(left);
-
+			
 			this.dispatchExternal("pageLoaded", this.getPage());
-
+			
 			return Promise.resolve();
-
+			
 			case "remote":
 			this.dataChanging = true;
 			return this.reloadData(null)
 			.finally(() => {
 				this.dataChanging = false;
 			})
-
+			
 			case "progressive_load":
 			case "progressive_scroll":
 			return this.reloadData(null, true);
-
+			
 			default:
 			console.warn("Pagination Error - no such pagination mode:", this.mode);
 			return Promise.reject();
 		}
 	}
-
+	
 	_parseRemoteData(data){
 		var data, margin;
-
+		
 		if(typeof data.last_page === "undefined"){
-			console.warn("Remote Pagination Error - Server response missing '" + this.dataReceivedNames.last_page + "' property");
+			console.warn("Remote Pagination Error - Server response missing '" + (this.options("dataReceiveParams").last_page || "last_page") + "' property");
 		}
-
+		
 		if(data.data){
 			this.max = parseInt(data.last_page) || 1;
 
+			this.remoteRowCountEstimate = typeof data.last_row !== "undefined" ? data.last_row : (data.last_page * this.size - (this.page == data.last_page ? (this.size - data.data.length) : 0));
+			
 			if(this.progressiveLoad){
 				switch(this.mode){
 					case "progressive_load":
-
+					
 					if(this.page == 1){
 						this.table.rowManager.setData(data.data, false, this.page == 1);
 					}else {
 						this.table.rowManager.addRows(data.data);
 					}
-
+					
 					if(this.page < this.max){
 						setTimeout(() => {
 							this.nextPage();
 						}, this.table.options.progressiveLoadDelay);
 					}
 					break;
-
+					
 					case "progressive_scroll":
-					data = this.table.rowManager.getData().concat(data.data);
-
+					data = this.page === 1 ? data.data : this.table.rowManager.getData().concat(data.data);
+					
 					this.table.rowManager.setData(data, this.page !== 1, this.page == 1);
-
+					
 					margin = this.table.options.progressiveLoadScrollMargin || (this.table.rowManager.element.clientHeight * 2);
-
+					
 					if(this.table.rowManager.element.scrollHeight <= (this.table.rowManager.element.clientHeight + margin)){
 						setTimeout(() => {
 							this.nextPage();
@@ -14610,7 +15101,7 @@ class Page extends Module{
 					}
 					break;
 				}
-
+				
 				return false;
 			}else {
 				// left = this.table.rowManager.scrollLeft;
@@ -14618,23 +15109,23 @@ class Page extends Module{
 				// this.table.rowManager.scrollHorizontal(left);
 				// this.table.columnManager.scrollHorizontal(left);
 			}
-
+			
 		}else {
-			console.warn("Remote Pagination Error - Server response missing '" + this.dataReceivedNames.data + "' property");
+			console.warn("Remote Pagination Error - Server response missing '" + (this.options("dataReceiveParams").data || "data") + "' property");
 		}
-
+		
 		return data.data;
 	}
-
+	
 	//handle the footer element being redrawn
 	footerRedraw(){
 		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';
 			}
@@ -14642,7 +15133,10 @@ class Page extends Module{
 	}
 }
 
-Page.moduleName = "page";
+Page.moduleName = "page";
+
+//load defaults
+Page.pageCounters = defaultPageCounters;
 
 // read peristence information from storage
 var defaultReaders = {
@@ -15874,7 +16368,7 @@ class ResizeRows extends Module{
 
 			self.table.element.classList.remove("tabulator-block-select");
 
-			this.dispatchExternal("rowResized", row.getComponent());
+			self.dispatchExternal("rowResized", row.getComponent());
 		}
 
 		e.stopPropagation(); //prevent resize from interfereing with movable columns
@@ -16045,7 +16539,7 @@ class ResponsiveLayout extends Module{
 		this.registerColumnOption("responsive");
 	}
 
-	//generate resposive columns list
+	//generate responsive columns list
 	initialize(){
 
 		if(this.table.options.responsiveLayout){
@@ -16082,7 +16576,7 @@ class ResponsiveLayout extends Module{
 		this.collapseStartOpen = this.table.options.responsiveLayoutCollapseStartOpen;
 		this.hiddenColumns = [];
 
-		//detemine level of responsivity for each column
+		//determine 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){
@@ -16164,10 +16658,8 @@ class ResponsiveLayout extends Module{
 	updateColumnVisibility(column, responsiveToggle){
 		if(!responsiveToggle && column.modules.responsive){
 			column.modules.responsive.visible = column.visible;
-			this.initialize();
+			this.initializeResponsivity();
 		}
-
-		//this.update();
 	}
 
 	hideColumn(column){
@@ -16405,7 +16897,7 @@ class SelectRow extends Module{
 			this.subscribe("rows-wipe", this.clearSelectionData.bind(this));
 			this.subscribe("rows-retrieve", this.rowRetrieve.bind(this));
 
-			if(this.table.options.selectable && this.table.options.selectablePersistence){
+			if(this.table.options.selectable && !this.table.options.selectablePersistence){
 				this.subscribe("data-refeshing", this.deselectRows.bind(this));
 			}
 		}
@@ -16644,9 +17136,7 @@ class SelectRow extends Module{
 					this.childRowSelection(row, true);
 				}
 
-				if(!silent){
-					this.dispatchExternal("rowSelected", row.getComponent());
-				}
+				this.dispatchExternal("rowSelected", row.getComponent());
 
 				this._rowSelectionChanged(silent);
 			}
@@ -16665,7 +17155,7 @@ class SelectRow extends Module{
 	deselectRows(rows, silent){
 		var self = this,
 		rowCount;
-
+		
 		if(typeof rows == "undefined"){
 
 			rowCount = self.selectedRows.length;
@@ -16717,9 +17207,7 @@ class SelectRow extends Module{
 					this.childRowSelection(row, false);
 				}
 
-				if(!silent){
-					this.dispatchExternal("rowDeselected", row.getComponent());
-				}
+				this.dispatchExternal("rowDeselected", row.getComponent());
 
 				self._rowSelectionChanged(silent);
 			}
@@ -16883,8 +17371,9 @@ function datetime$1(a, b, aRow, bRow, column, dir, params){
 	emptyAlign = 0;
 
 	if(typeof DT != "undefined"){
-		a = DT.fromFormat(a, format);
-		b = DT.fromFormat(b, format);
+		a = format === "iso" ? DT.fromISO(String(a)) : DT.fromFormat(String(a), format);
+		b = format === "iso" ? DT.fromISO(String(b)) : DT.fromFormat(String(b), format);
+
 		if(!a.isValid){
 			emptyAlign = !b.isValid ? 0 : -1;
 		}else if(!b.isValid){
@@ -17255,7 +17744,7 @@ class Sort extends Module{
 		if(this.table.options.sortMode === "remote"){
 			this.reloadData();
 		}else {
-			this.refreshData();
+			this.refreshData(true);
 		}
 
 		//TODO - Persist left position of row manager
@@ -17659,7 +18148,7 @@ class Validate extends Module{
 	columnValidate(column){
 		var invalid = [];
 
-		column.cells.forEach(function(cell){
+		column.cells.forEach((cell) => {
 			if(!this.cellValidate(cell)){
 				invalid.push(cell.getComponent());
 			}
@@ -17675,7 +18164,7 @@ class Validate extends Module{
 	rowValidate(row){
 		var invalid = [];
 
-		row.cells.forEach(function(cell){
+		row.cells.forEach((cell) => {
 			if(!this.cellValidate(cell)){
 				invalid.push(cell.getComponent());
 			}
@@ -17707,7 +18196,9 @@ class Validate extends Module{
 		var output = [];
 
 		//clear row data
-		this.table.rowManager.rows.forEach(function(row){
+		this.table.rowManager.rows.forEach((row) => {
+			row = row.getComponent();
+
 			var valid = row.validate();
 
 			if(valid !== true){
@@ -17737,7 +18228,7 @@ class Validate extends Module{
 		if(column.definition.validator){
 
 			if(Array.isArray(column.definition.validator)){
-				column.definition.validator.forEach(function(item){
+				column.definition.validator.forEach((item) => {
 					validator = self._extractValidator(item);
 
 					if(validator){
@@ -17803,7 +18294,7 @@ class Validate extends Module{
 		invalidIndex = this.invalidCells.indexOf(cell);
 
 		if(validators){
-			validators.forEach(function(item){
+			validators.forEach((item) => {
 				if(!item.func.call(self, cell.getComponent(), value, item.params)){
 					valid.push({
 						type:item.type,
@@ -17890,6 +18381,7 @@ var modules = /*#__PURE__*/Object.freeze({
 	GroupRowsModule: GroupRows,
 	HistoryModule: History,
 	HtmlTableImportModule: HtmlTableImport,
+	ImportModule: Import,
 	InteractionModule: Interaction,
 	KeybindingsModule: Keybindings,
 	MenuModule: Menu,
@@ -17909,7 +18401,7 @@ var modules = /*#__PURE__*/Object.freeze({
 	ValidateModule: Validate
 });
 
-var defaultOptions$1 = {
+var defaultOptions = {
 
 	debugEventsExternal:false, //flag to console log events
 	debugEventsInternal:false, //flag to console log events
@@ -17919,7 +18411,6 @@ var defaultOptions$1 = {
 	minHeight:false, //minimum height of tabulator
 	maxHeight:false, //maximum height of tabulator
 
-	columnMaxWidth:false, //minimum global width for a column
 	columnHeaderVertAlign:"top", //vertical alignment of column headers
 
 	columns:[],//store for colum header info
@@ -17930,7 +18421,7 @@ var defaultOptions$1 = {
 	autoColumns:false, //build columns from data row structure
 	autoColumnsDefinitions:false,
 
-	nestedFieldSeparator:".", //seperatpr for nested data
+	nestedFieldSeparator:".", //separator for nested data
 
 	tooltipGenerationMode:"load", //when to generate tooltips
 
@@ -17964,6 +18455,7 @@ var defaultOptions$1 = {
 	dataLoader:true,
 	dataLoaderLoading:false,
 	dataLoaderError:false,
+	dataLoaderErrorTimeout:3000,
 
 	dataSendParams:{},
 
@@ -17971,10 +18463,10 @@ var defaultOptions$1 = {
 };
 
 class OptionsList {
-	constructor(table, msgType){
+	constructor(table, msgType, defaults = {}){
 		this.table = table;
 		this.msgType = msgType;
-		this.registeredDefaults = {};
+		this.registeredDefaults = Object.assign({}, defaults);
 	}
 
 	register(option, value){
@@ -18090,7 +18582,7 @@ class Renderer extends CoreFeature{
 	}
 
 	scrollToRowNearestTop(row){
-		//determin weather the row is nearest the top or bottom of the table, retur true for top or false for bottom
+		//determine weather the row is nearest the top or bottom of the table, retur true for top or false for bottom
 	}
 
 	visibleRows(includingBuffer){
@@ -18157,8 +18649,9 @@ class Renderer extends CoreFeature{
 				if(!ifVisible){
 					if(Helpers.elVisible(rowEl)){
 						offset = Helpers.elOffset(rowEl).top - Helpers.elOffset(this.elementVertical).top;
-
+						
 						if(offset > 0 && offset < this.elementVertical.clientHeight - rowEl.offsetHeight){
+							resolve();
 							return false;
 						}
 					}
@@ -18231,157 +18724,157 @@ class BaiscHorizontal extends Renderer{
 class VirtualDomHorizontal extends Renderer{
 	constructor(table){
 		super(table);
-
+		
 		this.leftCol = 0;
 		this.rightCol = 0;
 		this.scrollLeft = 0;
-
+		
 		this.vDomScrollPosLeft = 0;
 		this.vDomScrollPosRight = 0;
-
+		
 		this.vDomPadLeft = 0;
 		this.vDomPadRight = 0;
-
+		
 		this.fitDataColAvg = 0;
-
+		
 		this.window = 200; //pixel margin to make column visible before it is shown on screen
-
+		
 		this.initialized = false;
-
+		
 		this.columns = [];
 	}
-
+	
 	initialize(){
-		this.compatabilityCheck();
+		this.compatibilityCheck();
 	}
-
-	compatabilityCheck(){
+	
+	compatibilityCheck(){
 		var columns = this.options("columns"),
 		frozen = false,
 		ok = true;
-
+		
 		if(this.options("layout") == "fitDataTable"){
-			console.warn("Horizontal Vitrual DOM is not compatible with fitDataTable layout mode");
+			console.warn("Horizontal Virtual DOM is not compatible with fitDataTable layout mode");
 			ok = false;
 		}
-
+		
 		if(this.options("responsiveLayout")){
-			console.warn("Horizontal Vitrual DOM is not compatible with responsive columns");
+			console.warn("Horizontal Virtual DOM is not compatible with responsive columns");
 			ok = false;
 		}
-
+		
 		if(this.options("rtl")){
-			console.warn("Horizontal Vitrual DOM is not currently compatible with RTL text direction");
+			console.warn("Horizontal Virtual DOM is not currently compatible with RTL text direction");
 			ok = false;
 		}
-
+		
 		if(columns){
 			frozen = columns.find((col) => {
 				return col.frozen;
 			});
-
+			
 			if(frozen){
-				console.warn("Horizontal Vitrual DOM is not compatible with frozen columns");
+				console.warn("Horizontal Virtual DOM is not compatible with frozen columns");
 				ok = false;
 			}
 		}
-
+		
 		// if(!ok){
 		// 	options.virtualDomHoz = false;
 		// }
-
+		
 		return ok;
 	}
-
+	
 	//////////////////////////////////////
 	///////// Public Functions ///////////
 	//////////////////////////////////////
-
+	
 	renderColumns(row, force){
 		this.dataChange();
 	}
-
+	
 	scrollColumns(left, dir){
 		if(this.scrollLeft != left){
 			this.scrollLeft = left;
-
+			
 			this.scroll(left - (this.vDomScrollPosLeft + this.window));
 		}
 	}
-
-	rerenderColumns(update, blockRedraw){
+	
+	rerenderColumns(update, blockRedraw){		
 		var old = {
 			cols:this.columns,
 			leftCol:this.leftCol,
 			rightCol:this.rightCol,
 		};
-
+		
 		if(update && !this.initialized){
 			return;
 		}
-
+		
 		this.clear();
-
+		
 		this.scrollLeft = this.elementVertical.scrollLeft;
-
+		
 		this.vDomScrollPosLeft = this.scrollLeft - this.window;
 		this.vDomScrollPosRight = this.scrollLeft + this.elementVertical.clientWidth + this.window;
-
+		
 		var colPos = 0;
-
+		
 		this.table.columnManager.columnsByIndex.forEach((column) => {
 			var config = {};
-
+			
 			if(column.visible){
 				var width = column.getWidth();
-
+				
 				config.leftPos = colPos;
 				config.rightPos = colPos + width;
-
+				
 				config.width = width;
-
+				
 				if (this.options("layout") === "fitData") {
-					config.fitDataCheck = true;
+					config.fitDataCheck = column.modules.vdomHoz ? column.modules.vdomHoz.fitDataCheck : true;
 				}
-
+				
 				if((colPos + width > this.vDomScrollPosLeft) && (colPos < this.vDomScrollPosRight)){
-	        		//column is visible
-
-	        		if(this.leftCol == -1){
-	        			this.leftCol = this.columns.length;
-	        			this.vDomPadLeft = colPos;
-	        		}
-
-	        		this.rightCol = this.columns.length;
-	        	}else {
-	        		// column is hidden
-	        		if(this.leftCol !== -1){
-	        			this.vDomPadRight += width;
-	        		}
-	        	}
-
-	        	this.columns.push(column);
-
-	        	column.modules.vdomHoz = config;
-
-	        	colPos += width;
-	        }
-	    });
-
+					//column is visible
+					
+					if(this.leftCol == -1){
+						this.leftCol = this.columns.length;
+						this.vDomPadLeft = colPos;
+					}
+					
+					this.rightCol = this.columns.length;
+				}else {
+					// column is hidden
+					if(this.leftCol !== -1){
+						this.vDomPadRight += width;
+					}
+				}
+				
+				this.columns.push(column);
+				
+				column.modules.vdomHoz = config;
+				
+				colPos += width;
+			}
+		});
+		
 		this.tableElement.style.paddingLeft = this.vDomPadLeft + "px";
 		this.tableElement.style.paddingRight = this.vDomPadRight + "px";
-
+		
 		this.initialized = true;
-
+		
 		if(!blockRedraw){
 			if(!update || this.reinitChanged(old)){
-				this.renitializeRows();
+				this.reinitializeRows();
 			}
 		}
-
+		
 		this.elementVertical.scrollLeft = this.scrollLeft;
 	}
-
+	
 	renderRowCells(row){
 		if(this.initialized){
 			this.initializeRow(row);
@@ -18392,88 +18885,88 @@ class VirtualDomHorizontal extends Renderer{
 			});
 		}
 	}
-
+	
 	rerenderRowCells(row, force){
 		this.reinitializeRow(row, force);
 	}
-
+	
 	reinitializeColumnWidths(columns){
 		for(let i = this.leftCol; i <= this.rightCol; i++){
 			this.columns[i].reinitializeWidth();
 		}
 	}
-
+	
 	//////////////////////////////////////
 	//////// Internal Rendering //////////
 	//////////////////////////////////////
-
+	
 	deinitialize(){
 		this.initialized = false;
 	}
-
+	
 	clear(){
 		this.columns = [];
-
+		
 		this.leftCol = -1;
 		this.rightCol = 0;
-
+		
 		this.vDomScrollPosLeft = 0;
 		this.vDomScrollPosRight = 0;
 		this.vDomPadLeft = 0;
 		this.vDomPadRight = 0;
 	}
-
+	
 	dataChange(){
 		var change = false,
 		collsWidth = 0,
 		colEnd = 0,
 		row, rowEl;
-
+		
 		if(this.options("layout") === "fitData"){
 			this.table.columnManager.columnsByIndex.forEach((column) => {
 				if(!column.definition.width && column.visible){
 					change = true;
 				}
 			});
-
+			
 			if(change){
 				if(change && this.table.rowManager.getDisplayRows().length){
-
+					
 					this.vDomScrollPosRight = this.scrollLeft + this.elementVertical.clientWidth + this.window;
-
+					
 					var row = this.chain("rows-sample", [1], [], () => {
 						return this.table.rowManager.getDisplayRows()[0];
 					})[0];
-
+					
 					if(row){
-
+						
 						rowEl = row.getElement();
-
+						
 						row.generateCells();
-
+						
 						this.tableElement.appendChild(rowEl);
-
+						
 						for(var colEnd = 0; colEnd < row.cells.length; colEnd++){
 							let cell = row.cells[colEnd];
 							rowEl.appendChild(cell.getElement());
-
+							
 							cell.column.reinitializeWidth();
-
+							
 							collsWidth += cell.column.getWidth();
-
+							
 							if(collsWidth > this.vDomScrollPosRight){
 								break;
 							}
 						}
-
+						
 						rowEl.parentNode.removeChild(rowEl);
-
+						
 						this.fitDataColAvg = Math.floor(collsWidth / (colEnd + 1));
-
+						
 						for(colEnd; colEnd < this.table.columnManager.columnsByIndex.length; colEnd++){
 							this.table.columnManager.columnsByIndex[colEnd].setWidth(this.fitDataColAvg);
 						}
-
+						
 						this.rerenderColumns(false, true);
 					}
 				}
@@ -18485,34 +18978,34 @@ class VirtualDomHorizontal extends Renderer{
 			}
 		}
 	}
-
+	
 	reinitChanged(old){
 		var match = true;
-
+		
 		if(old.cols.length !== this.columns.length || old.leftCol !== this.leftCol || old.rightCol !== this.rightCol){
 			return true;
 		}
-
+		
 		old.cols.forEach((col, i) => {
 			if(col !== this.columns[i]){
 				match = false;
 			}
 		});
-
+		
 		return !match;
 	}
-
-	renitializeRows(){
+	
+	reinitializeRows(){
 		var rows = this.table.rowManager.getVisibleRows();
 		rows.forEach((row) => {
 			this.reinitializeRow(row, true);
 		});
 	}
-
+	
 	scroll(diff){
 		this.vDomScrollPosLeft += diff;
 		this.vDomScrollPosRight += diff;
-
+		
 		if(diff > (this.elementVertical.clientWidth * .8)){
 			this.rerenderColumns();
 		}else {
@@ -18527,24 +19020,23 @@ class VirtualDomHorizontal extends Renderer{
 			}
 		}
 	}
-
+	
 	colPositionAdjust (start, end, diff){
 		for(let i = start; i < end; i++){
 			let column = this.columns[i];
-
+			
 			column.modules.vdomHoz.leftPos += diff;
 			column.modules.vdomHoz.rightPos += diff;
 		}
 	}
-
+	
 	addColRight(){
 		var column = this.columns[this.rightCol + 1],
 		rows;
-
+		
 		if(column && column.modules.vdomHoz.leftPos <= this.vDomScrollPosRight){
-
 			rows = this.table.rowManager.getVisibleRows();
-
+			
 			rows.forEach((row) => {
 				if(row.type !== "group"){
 					var cell = row.getCell(column);
@@ -18552,30 +19044,30 @@ class VirtualDomHorizontal extends Renderer{
 					cell.cellRendered();
 				}
 			});
-
+			
 			this.fitDataColActualWidthCheck(column);
-
-			this.rightCol++;
-
+			
+			this.rightCol++; // Don't move this below the >= check below
+			
 			if(this.rightCol >= (this.columns.length - 1)){
 				this.vDomPadRight = 0;
 			}else {
 				this.vDomPadRight -= column.getWidth();
 			}
-
+			
 			this.tableElement.style.paddingRight = this.vDomPadRight + "px";
-
+			
 			this.addColRight();
 		}
 	}
-
+	
 	addColLeft(){
 		var column = this.columns[this.leftCol - 1],
 		rows;
-
+		
 		if(column && column.modules.vdomHoz.rightPos >= this.vDomScrollPosLeft){
 			var rows = this.table.rowManager.getVisibleRows();
-
+			
 			rows.forEach((row) => {
 				if(row.type !== "group"){
 					var cell = row.getCell(column);
@@ -18583,119 +19075,134 @@ class VirtualDomHorizontal extends Renderer{
 					cell.cellRendered();
 				}
 			});
-
+			
 			this.fitDataColActualWidthCheck(column);
+			
+			this.leftCol--; // don't move this below the <= check below
 
-			if(!this.leftCol){
+			if(this.leftCol <= 0){ // replicating logic in addColRight
 				this.vDomPadLeft = 0;
 			}else {
 				this.vDomPadLeft -= column.getWidth();
 			}
-
+			
 			this.tableElement.style.paddingLeft = this.vDomPadLeft + "px";
-
-			this.leftCol--;
-
+			
+			
 			this.addColLeft();
 		}
 	}
-
+	
 	removeColRight(column){
 		var column = this.columns[this.rightCol],
 		rows;
-
+		
 		if(column && column.modules.vdomHoz.leftPos > this.vDomScrollPosRight){
 			rows = this.table.rowManager.getVisibleRows();
-
+			
 			column.modules.vdomHoz.visible = false;
-
+			
 			rows.forEach((row) => {
 				if(row.type !== "group"){
 					var cell = row.getCell(column);
-					row.getElement().removeChild(cell.getElement());
+					try {
+						row.getElement().removeChild(cell.getElement());
+					} catch (ex) {
+						console.warn("Could not removeColRight", ex.message);
+					}
 				}
 			});
-
+			
 			this.vDomPadRight += column.getWidth();
 			this.tableElement.style.paddingRight = this.vDomPadRight + "px";
-
+			
 			this.rightCol --;
-
+			
 			this.removeColRight();
 		}
 	}
-
+	
 	removeColLeft(){
 		var column = this.columns[this.leftCol],
 		rows;
-
-		if(column && column.modules.vdomHoz.rightPos < this.vDomScrollPosLeft){
-
+		
+		if(column && column.modules.vdomHoz.rightPos < this.vDomScrollPosLeft){	
 			rows = this.table.rowManager.getVisibleRows();
-
+			
 			rows.forEach((row) => {
+				var cell, el;
+
 				if(row.type !== "group"){
-					var cell = row.getCell(column);
-					if(cell.parentNode){
-						row.getElement().removeChild(cell.getElement());
+					cell = row.getCell(column);
+
+					if(cell){
+						el = cell.getElement();
+
+						if(el.parentNode){
+							try {
+								row.getElement().removeChild(el);
+							} catch (ex) {
+								console.warn("Could not removeColLeft", ex.message);
+							}
+						}
 					}
 				}
 			});
-
+			
 			this.vDomPadLeft += column.getWidth();
 			this.tableElement.style.paddingLeft = this.vDomPadLeft + "px";
-
+			
 			this.leftCol ++;
-
+			
 			this.removeColLeft();
 		}
 	}
-
+	
 	fitDataColActualWidthCheck(column){
 		var newWidth, widthDiff;
-
+		
 		if(column.modules.vdomHoz.fitDataCheck){
 			column.reinitializeWidth();
-
+			
 			newWidth = column.getWidth();
 			widthDiff = newWidth - column.modules.vdomHoz.width;
-
+			
 			if(widthDiff){
 				column.modules.vdomHoz.rightPos += widthDiff;
 				column.modules.vdomHoz.width = newWidth;
 				this.colPositionAdjust(this.rightCol + 2, this.columns.length, widthDiff);
 			}
-
+			
 			column.modules.vdomHoz.fitDataCheck = false;
 		}
 	};
-
+	
 	initializeRow(row){
 		if(row.type !== "group"){
 			row.modules.vdomHoz = {
 				leftCol:this.leftCol,
 				rightCol:this.rightCol,
 			};
-
+			
 			for(let i = this.leftCol; i <= this.rightCol; i++){
 				let column = this.columns[i];
-
+				
 				if(column && column.visible){
 					let cell = row.getCell(column);
-
+					
 					row.getElement().appendChild(cell.getElement());
 					cell.cellRendered();
 				}
 			}
 		}
 	}
-
+	
 	reinitializeRow(row, force){
 		if(row.type !== "group"){
 			if(force || !row.modules.vdomHoz || row.modules.vdomHoz.leftCol !== this.leftCol || row.modules.vdomHoz.rightCol !== this.rightCol){
 				var rowEl = row.getElement();
 				while(rowEl.firstChild) rowEl.removeChild(rowEl.firstChild);
-
+				
 				this.initializeRow(row);
 			}
 		}
@@ -18714,7 +19221,7 @@ class ColumnManager extends CoreFeature {
 		this.columnsByIndex = []; //columns by index
 		this.columnsByField = {}; //columns by field
 		this.scrollLeft = 0;
-		this.optionsList = new OptionsList(this.table, "column definition");
+		this.optionsList = new OptionsList(this.table, "column definition", defaultColumnOptions);
 
 		this.renderer = null;
 	}
@@ -19043,7 +19550,7 @@ class ColumnManager extends CoreFeature {
 		return this.columnsByIndex[index];
 	}
 
-	getFirstVisibileColumn(index){
+	getFirstVisibleColumn(index){
 		var index = this.columnsByIndex.findIndex((col) => {
 			return col.visible;
 		});
@@ -19419,7 +19926,8 @@ class BaiscVertical extends Renderer{
 
 
 	rerenderRows(callback){
-		this.render();
+		this.clearRows();
+		this.renderRows();
 
 		if(callback){
 			callback();
@@ -19487,7 +19995,7 @@ class VirtualDomVertical extends Renderer{
 
 		element.style.paddingTop = "";
 		element.style.paddingBottom = "";
-		element.style.minWidth = "";
+		// element.style.minWidth = "";
 		element.style.minHeight = "";
 		element.style.display = "";
 		element.style.visibility = "";
@@ -20027,7 +20535,7 @@ class RowManager extends CoreFeature{
 		this.fixedHeight = false; //current rendering mode
 
 		this.rows = []; //hold row data objects
-		this.activeRowsPipeline = []; //hold caluclation of active rows
+		this.activeRowsPipeline = []; //hold calculation of active rows
 		this.activeRows = []; //rows currently available to on display in the table
 		this.activeRowsCount = 0; //count of active rows
 
@@ -20039,9 +20547,9 @@ class RowManager extends CoreFeature{
 
 		this.rowNumColumn = false; //hold column component for row number column
 
-		this.redrawBlock = false; //prevent redraws to allow multiple data manipulations becore continuing
+		this.redrawBlock = false; //prevent redraws to allow multiple data manipulations before continuing
 		this.redrawBlockRestoreConfig = false; //store latest redraw function calls for when redraw is needed
-		this.redrawBlockRederInPosition = false; //store latest redraw function calls for when redraw is needed
+		this.redrawBlockRenderInPosition = false; //store latest redraw function calls for when redraw is needed
 
 		this.dataPipeline = []; //hold data pipeline tasks
 		this.displayPipeline = []; //hold data display pipeline tasks
@@ -20712,7 +21220,7 @@ class RowManager extends CoreFeature{
 				}
 			}
 
-			this.dispatch("data-refeshed");
+			this.dispatch("data-refreshed");
 		}
 	}
 
@@ -20775,8 +21283,14 @@ class RowManager extends CoreFeature{
 		}
 	}
 
-	getVisibleRows(viewable){
-		return this.renderer.visibleRows(!viewable);
+	getVisibleRows(chain, viewable){
+		var rows =  Object.assign([], this.renderer.visibleRows(!viewable));
+
+		if(chain){
+			rows = this.chain("rows-visible", [viewable], rows, rows);
+		}
+
+		return rows;
 	}
 
 	//repeat action accross display rows
@@ -20818,7 +21332,7 @@ class RowManager extends CoreFeature{
 			if(callback){
 				callback();
 			}else {
-				this.redrawBlockRederInPosition = true;
+				this.redrawBlockRenderInPosition = true;
 			}
 		}else {
 			this.renderer.rerenderRows(callback);
@@ -20997,12 +21511,12 @@ class RowManager extends CoreFeature{
 
 			this.redrawBlockRestoreConfig = false;
 		}else {
-			if(this.redrawBlockRederInPosition){
+			if(this.redrawBlockRenderInPosition){
 				this.reRenderInPosition();
 			}
 		}
 
-		this.redrawBlockRederInPosition = false;
+		this.redrawBlockRenderInPosition = false;
 	}
 
 	//redraw table
@@ -21140,29 +21654,29 @@ class FooterManager extends CoreFeature{
 }
 
 class InteractionManager extends CoreFeature {
-
+	
 	constructor (table){
 		super(table);
-
-		this.el = this.table.element;
-
+		
+		this.el = null;
+		
 		this.abortClasses = ["tabulator-headers", "tabulator-table"];
-
+		
 		this.previousTargets = {};
-
+		
 		this.listeners = [
-		"click",
-		"dblclick",
-		"contextmenu",
-		"mouseenter",
-		"mouseleave",
-		"mouseover",
-		"mouseout",
-		"mousemove",
-		"touchstart",
-		"touchend",
+			"click",
+			"dblclick",
+			"contextmenu",
+			"mouseenter",
+			"mouseleave",
+			"mouseover",
+			"mouseout",
+			"mousemove",
+			"touchstart",
+			"touchend",
 		];
-
+		
 		this.componentMap = {
 			"tabulator-cell":"cell",
 			"tabulator-row":"row",
@@ -21170,36 +21684,111 @@ class InteractionManager extends CoreFeature {
 			"tabulator-col":"column",
 		};
 
+		this.pseudoTrackers = {
+			"row":{
+				subscriber:null,
+				target:null,
+			},
+			"cell":{
+				subscriber:null,
+				target:null,
+			},
+			"group":{
+				subscriber:null,
+				target:null,
+			},
+			"column":{
+				subscriber:null,
+				target:null,
+			},
+		};
+
+		this.pseudoTracking = false;
+	}
+	
+	initialize(){
+		this.el = this.table.element;
 		this.buildListenerMap();
 		this.bindSubscriptionWatchers();
 	}
-
+	
 	buildListenerMap(){
 		var listenerMap = {};
-
+		
 		this.listeners.forEach((listener) => {
 			listenerMap[listener] = {
 				handler:null,
 				components:[],
 			};
 		});
-
+		
 		this.listeners = listenerMap;
 	}
 
+	bindPseudoEvents(){
+		Object.keys(this.pseudoTrackers).forEach((key) => {
+			this.pseudoTrackers[key].subscriber = this.pseudoMouseEnter.bind(this, key);
+			this.subscribe(key + "-mouseover", this.pseudoTrackers[key].subscriber);
+		});
+
+		this.pseudoTracking = true;
+	}
+
+	pseudoMouseEnter(key, e, target){
+		if(this.pseudoTrackers[key].target !== target){
+			
+			if(this.pseudoTrackers[key].target){
+				this.dispatch(key + "-mouseleave", e, target);
+			}
+
+			this.pseudoMouseLeave(key, e);
+
+			this.pseudoTrackers[key].target = target;
+
+			this.dispatch(key + "-mouseenter", e, target);
+		}
+	}
+
+	pseudoMouseLeave(key, e){
+		var leaveList = Object.keys(this.pseudoTrackers),
+		linkedKeys = {
+			"row":["cell"],
+			"cell":["row"],
+		};
+
+		leaveList = leaveList.filter((item) => {
+			var links = linkedKeys[key];
+			return item !== key && (!links || (links && !links.includes(item)));
+		});
+
+	
+		leaveList.forEach((key) => {
+			var target = this.pseudoTrackers[key].target;
+
+			if(this.pseudoTrackers[key].target){
+				this.dispatch(key + "-mouseleave", e, target);
+
+				this.pseudoTrackers[key].target = null;
+			}
+		});
+	}
+
+	
 	bindSubscriptionWatchers(){
 		var listeners = Object.keys(this.listeners),
 		components = Object.values(this.componentMap);
-
+		
 		for(let comp of components){
 			for(let listener of listeners){
 				let key = comp + "-" + listener;
-
+				
 				this.subscriptionChange(key, this.subscriptionChanged.bind(this, comp, listener));
 			}
 		}
+		
+		this.subscribe("table-destroy", this.clearWatchers.bind(this));
 	}
-
+	
 	subscriptionChanged(component, key, added){
 		var listener = this.listeners[key].components,
 		index = listener.indexOf(component),
@@ -21219,15 +21808,19 @@ class InteractionManager extends CoreFeature {
 			}
 		}
 
+		if((key === "mouseenter" || key === "mouseleave") && !this.pseudoTracking){
+			this.bindPseudoEvents();
+		}
+		
 		if(changed){
 			this.updateEventListeners();
 		}
 	}
-
+	
 	updateEventListeners(){
 		for(let key in this.listeners){
 			let listener = this.listeners[key];
-
+			
 			if(listener.components.length){
 				if(!listener.handler){
 					listener.handler = this.track.bind(this, key);
@@ -21242,86 +21835,96 @@ class InteractionManager extends CoreFeature {
 			}
 		}
 	}
-
+	
 	track(type, e){
 		var path = (e.composedPath && e.composedPath()) || e.path;
+		
 		var targets = this.findTargets(path);
 		targets = this.bindComponents(type, targets);
+
 		this.triggerEvents(type, e, targets);
-	}
 
+		if(this.pseudoTracking && (type == "mouseover" || type == "mouseleave") && !Object.keys(targets).length){
+			this.pseudoMouseLeave("none", e);
+		}
+	}
+	
 	findTargets(path){
 		var targets = {};
-
+		
 		let componentMap = Object.keys(this.componentMap);
-
+		
 		for (let el of path) {
 			let classList = el.classList ? [...el.classList] : [];
-
+			
 			let abort = classList.filter((item) => {
 				return this.abortClasses.includes(item);
 			});
-
+			
 			if(abort.length){
 				break;
 			}
-
+			
 			let elTargets = classList.filter((item) => {
 				return componentMap.includes(item);
 			});
-
+			
 			for (let target of elTargets) {
 				targets[this.componentMap[target]] = el;
 			}
 		}
-
+		
 		if(targets.group && targets.group === targets.row){
 			delete targets.row;
 		}
-
+		
 		return targets;
 	}
-
+	
 	bindComponents(type, targets){
 		//ensure row component is looked up before cell
 		var keys = Object.keys(targets).reverse(),
 		listener = this.listeners[type],
 		targetMatches = {};
-
+		
 		for(let key of keys){
 			let component;
 			let target = targets[key];
 			let previousTarget = this.previousTargets[key];
-
+			
 			if(previousTarget && previousTarget.target === target){
 				component = previousTarget.component;
 			}else {
 				switch(key){
 					case "row":
 					case "group":
-					if(listener.components.includes("row") || listener.components.includes("cell")){
-						let rows = this.table.rowManager.getVisibleRows();
-
+					if(listener.components.includes("row") || listener.components.includes("cell") || listener.components.includes("group")){
+						let rows = this.table.rowManager.getVisibleRows(true);
+						
 						component = rows.find((row) => {
 							return row.getElement() === target;
 						});
 					}
 					break;
-
+					
 					case "column":
 					if(listener.components.includes("column")){
 						component = this.table.columnManager.findColumn(target);
 					}
 					break
-
+					
 					case "cell":
 					if(listener.components.includes("cell")){
-						component = targets["row"].findCell(target);
+						if(targets["row"]){
+							component = targets["row"].findCell(target);
+						}else {
+							console.warn("Event Target Lookup Error - The row this cell is attached to cannot be found, has the table been reinitialized without being destroyed first?");
+						}
 					}
 					break;
 				}
 			}
-
+			
 			if(component){
 				targets[key] = component;
 				targetMatches[key] = {
@@ -21330,24 +21933,35 @@ class InteractionManager extends CoreFeature {
 				};
 			}
 		}
-
+		
 		this.previousTargets = targetMatches;
-
+		
 		return targets;
 	}
-
+	
 	triggerEvents(type, e, targets){
 		var listener = this.listeners[type];
-
+		
 		for(let key in targets){
 			if(targets[key] && listener.components.includes(key)){
 				this.dispatch(key + "-" + type, e, targets[key]);
 			}
 		}
 	}
+	
+	clearWatchers(){
+		for(let key in this.listeners){
+			let listener = this.listeners[key];
+		
+			if(listener.handler){
+				this.el.removeEventListener(key, listener.handler);
+				listener.handler = null;
+			}
+		}
+	}
 }
 
-class ComponentFuctionBinder{
+class ComponentFunctionBinder{
 
 	constructor(table){
 		this.table = table;
@@ -21442,7 +22056,7 @@ class DataLoader extends CoreFeature{
 			data = JSON.parse(data);
 		}
 
-		if(this.confirm("data-loading", data, params, config, silent)){
+		if(this.confirm("data-loading", [data, params, config, silent])){
 			this.loading = true;
 
 			if(!silent){
@@ -21450,12 +22064,12 @@ class DataLoader extends CoreFeature{
 			}
 
 			//get params for request
-			var params = this.chain("data-params", [data, config, silent], params || {}, {});
+			params = this.chain("data-params", [data, config, silent], params || {}, params || {});
 
 			params = this.mapParams(params, this.table.options.dataSendParams);
 
-			var result = this.chain("data-load", [data, params, config, silent], Promise.resolve([]));
-
+			var result = this.chain("data-load", [data, params, config, silent], false, Promise.resolve([]));
+			
 			return result.then((response) => {
 				if(!Array.isArray(response) && typeof response == "object"){
 					response = this.mapParams(response, this.objectInvert(this.table.options.dataReceiveParams));
@@ -21480,10 +22094,10 @@ class DataLoader extends CoreFeature{
 				if(!silent){
 					this.showError();
 				}
-
+				
 				setTimeout(() => {
 					this.hideLoader();
-				}, 3000);
+				}, this.table.options.dataLoaderErrorTimeout);
 			})
 			.finally(() => {
 				this.loading = false;
@@ -22210,6 +22824,12 @@ var defaultLangs = {
 			"next":"Next",
 			"next_title":"Next Page",
 			"all":"All",
+			"counter":{
+				"showing": "Showing",
+				"of": "of",
+				"rows": "rows",
+				"pages": "pages",
+			}
 		},
 		"headerFilters":{
 			"default":"filter column...",
@@ -22560,11 +23180,11 @@ class Tabulator {
 		this.interactionMonitor = false; //track user interaction
 		this.browser = ""; //hold current browser type
 		this.browserSlow = false; //handle reduced functionality for slower browsers
-		this.browserMobile = false; //check if running on moble, prevent resize cancelling edit on keyboard appearence
+		this.browserMobile = false; //check if running on mobile, prevent resize cancelling edit on keyboard appearance
 		this.rtl = false; //check if the table is in RTL mode
 		this.originalElement = null; //hold original table element if it has been replaced
 
-		this.componentFunctionBinder = new ComponentFuctionBinder(this); //bind component functions
+		this.componentFunctionBinder = new ComponentFunctionBinder(this); //bind component functions
 		this.dataLoader = false; //bind component functions
 
 		this.modules = {}; //hold all modules bound to this table
@@ -22579,13 +23199,13 @@ class Tabulator {
 
 			this.initialzeCoreSystems(options);
 
-			//delay table creation to allow event bindings immediatly after the constructor
+			//delay table creation to allow event bindings immediately after the constructor
 			setTimeout(() => {
 				this._create();
 			});
 		}
 
-		TableRegistry.register(this); //register table for inderdevice communication
+		TableRegistry.register(this); //register table for inter-device communication
 	}
 
 	initializeElement(element){
@@ -22619,7 +23239,7 @@ class Tabulator {
 
 		this._clearObjectPointers();
 
-		this._mapDepricatedFunctionality();
+		this._mapDeprecatedFunctionality();
 
 		this.externalEvents = new ExternalEventBus(this, this.options, this.options.debugEventsExternal);
 		this.eventBus = new InternalEventBus(this.options.debugEventsInternal);
@@ -22632,8 +23252,8 @@ class Tabulator {
 		this.footerManager.initialize();
 	}
 
-	//convert depricated functionality to new functions
-	_mapDepricatedFunctionality(){
+	//convert deprecated functionality to new functions
+	_mapDeprecatedFunctionality(){
 		//all previously deprecated functionality removed in the 5.0 release
 	}
 
@@ -22654,7 +23274,7 @@ class Tabulator {
 		this.element.classList.remove("tabulator-block-select");
 	}
 
-	//concreate table
+	//create table
 	_create(){
 		this.externalEvents.dispatch("tableBuilding");
 		this.eventBus.dispatch("table-building");
@@ -22758,6 +23378,8 @@ class Tabulator {
 		var element = this.element,
 		options = this.options;
 
+		this.interactionMonitor.initialize();
+
 		this.columnManager.initialize();
 		this.rowManager.initialize();
 
@@ -22816,7 +23438,7 @@ class Tabulator {
 	destroy(){
 		var element = this.element;
 
-		TableRegistry.deregister(this); //deregister table from inderdevice communication
+		TableRegistry.deregister(this); //deregister table from inter-device communication
 
 		this.eventBus.dispatch("table-destroy");
 
@@ -22865,49 +23487,6 @@ class Tabulator {
 		return this.rowManager.restoreRedraw();
 	}
 
-	//local data from local file
-	setDataFromLocalFile(extensions){
-		return new Promise((resolve, reject) => {
-			var input = document.createElement("input");
-			input.type = "file";
-			input.accept = extensions || ".json,application/json";
-
-			input.addEventListener("change", (e) => {
-				var file = input.files[0],
-				reader = new FileReader(),
-				data;
-
-				reader.readAsText(file);
-
-				reader.onload = (e) => {
-
-					try {
-						data = JSON.parse(reader.result);
-					} catch(e) {
-						console.warn("File Load Error - File contents is invalid JSON", e);
-						reject(e);
-						return;
-					}
-
-					this.setData(data)
-					.then((data) => {
-						resolve(data);
-					})
-					.catch((err) => {
-						resolve(err);
-					});
-				};
-
-				reader.onerror = (e) => {
-					console.warn("File Load Error - Unable to read file");
-					reject();
-				};
-			});
-
-			input.click();
-		});
-	}
-
 	//load data
 	setData(data, params, config){
 		if(this.initialized){
@@ -23169,7 +23748,7 @@ class Tabulator {
 		if(row){
 			return row.updateData(data)
 			.then(()=>{
-				resolve(row.getComponent());
+				return Promise.resolve(row.getComponent());
 			})
 		}else {
 			console.warn("Update Error - No matching row found:", index);
@@ -23200,11 +23779,7 @@ class Tabulator {
 	}
 
 	getRows(active){
-		if(this.initialized){
-			return this.rowManager.getComponents(active);
-		}else {
-			console.warn("getRows failed - table not yet initialized. Please wait for the `tableBuilt` event before calling this function.");
-		}
+		return this.rowManager.getComponents(active);
 	}
 
 	//get position of row in table
@@ -23403,7 +23978,7 @@ class Tabulator {
 }
 
 //default setup options
-Tabulator.defaultOptions = defaultOptions$1;
+Tabulator.defaultOptions = defaultOptions;
 
 //bind modules and static functionality
 new ModuleBinder(Tabulator);
@@ -23460,5 +24035,5 @@ class PseudoRow {
 	clearCellHeight(){}
 }
 
-export { Accessor as AccessorModule, Ajax as AjaxModule, CalcComponent, CellComponent, Clipboard as ClipboardModule, ColumnCalcs as ColumnCalcsModule, ColumnComponent, DataTree as DataTreeModule, Download as DownloadModule, Edit as EditModule, Export as ExportModule, Filter as FilterModule, Format as FormatModule, FrozenColumns as FrozenColumnsModule, FrozenRows as FrozenRowsModule, GroupComponent, GroupRows as GroupRowsModule, History as HistoryModule, HtmlTableImport as HtmlTableImportModule, Interaction as InteractionModule, Keybindings as KeybindingsModule, Menu as MenuModule, Module, MoveColumns as MoveColumnsModule, MoveRows as MoveRowsModule, Mutator as MutatorModule, Page as PageModule, Persistence as PersistenceModule, Print as PrintModule, PseudoRow, ReactiveData as ReactiveDataModule, Renderer, ResizeColumns as ResizeColumnsModule, ResizeRows as ResizeRowsModule, ResizeTable as ResizeTableModule, ResponsiveLayout as ResponsiveLayoutModule, RowComponent$1 as RowComponent, SelectRow as SelectRowModule, Sort as SortModule, Tabulator, TabulatorFull, Validate as ValidateModule };
+export { Accessor as AccessorModule, Ajax as AjaxModule, CalcComponent, CellComponent, Clipboard as ClipboardModule, ColumnCalcs as ColumnCalcsModule, ColumnComponent, DataTree as DataTreeModule, Download as DownloadModule, Edit as EditModule, Export as ExportModule, Filter as FilterModule, Format as FormatModule, FrozenColumns as FrozenColumnsModule, FrozenRows as FrozenRowsModule, GroupComponent, GroupRows as GroupRowsModule, History as HistoryModule, HtmlTableImport as HtmlTableImportModule, Import as ImportModule, Interaction as InteractionModule, Keybindings as KeybindingsModule, Menu as MenuModule, Module, MoveColumns as MoveColumnsModule, MoveRows as MoveRowsModule, Mutator as MutatorModule, Page as PageModule, Persistence as PersistenceModule, Print as PrintModule, PseudoRow, ReactiveData as ReactiveDataModule, Renderer, ResizeColumns as ResizeColumnsModule, ResizeRows as ResizeRowsModule, ResizeTable as ResizeTableModule, ResponsiveLayout as ResponsiveLayoutModule, RowComponent$1 as RowComponent, SelectRow as SelectRowModule, Sort as SortModule, Tabulator, TabulatorFull, Validate as ValidateModule };
 //# sourceMappingURL=tabulator_esm.js.map