tabulator-rails 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0ce02d77017861dca0b48e89de5f680788e3160d
-  data.tar.gz: 921d059fa75bdfb5808f9ade0f369d23a1669d7f
+  metadata.gz: e09d2791c9a4a2cc558b7308f7907fe504230174
+  data.tar.gz: d4838f6293b296a720dd13db6ae90ed75a3d9015
 SHA512:
-  metadata.gz: 498b690ed246ed07a1047542d8e4a7cab7f6f604dd2b59bc471acffd909ccb14ae49e7159c2de7971c44ed16c89fe46c633dd630c2c005b7b06a185ea94fe964
-  data.tar.gz: 771a02f54efe79a16bb81b1d1f32821e8f544903c0f085f17673c725dd416f1ef685fcf13170182de1087d39cb9d9bcaec43f5df618a2e179e15f24d247a64ae
+  metadata.gz: 6f741a1fb44fa629b7edf0a61ed99376e82b8a0e2cf0b4a609aff1e3b5a3dc02b4179157cfe61d9ea220285f0b17e1ae49fa7e1c83958834b1dd63d0bf37cd2e
+  data.tar.gz: ef226021e9f051c3369913ff2021f738c8b334edac1485f10352eb5e88bafbb433ccc3f468d5bf8a42a839b6abb8f32acfdb13ff70f27e6476c98073ea5d6263

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    tabulator-rails (0.1.0)
+    tabulator-rails (0.1.1)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -26,22 +26,22 @@ Or install it yourself as:
     $ gem install tabulator-rails
 
 
-And then edit your app/assets/stylesheets/application.css file to look something like:
+And then edit your app/assets/stylesheets/application.js file to look something like:
 ``` css
 /*
 *= require_self
 *= require jqeury
 *= require jquery-ui
-*= require tabulator-rails
+*= require tabulator
 *= require_tree .
 */
 ```
 
-tabulator-rails is dependant on jQuery, jQuery-UI, so make sure you have it in your Gemfile.
+**tabulator-rails is dependant on jQuery, jQuery-UI, so make sure you have it in your Gemfile.**
 
 And to your app/assets/stylesheets/application.css
 ``` css
-*= require tabulator-rails
+*= require tabulator
 ```
 
 ## Usage

data/VERSIONS.md

@@ -4,4 +4,5 @@
 |--------|-----------|
 | 0.1.0  | 3.3.3 
 | 0.1.1  | 3.3.3 
+| 0.2.0  | 3.4.0 
 

data/lib/tabulator-rails/version.rb

@@ -1,5 +1,5 @@
 module Tabulator
   module Rails
-    VERSION = "0.1.1"
+    VERSION = "0.2.0"
   end
 end

data/vendor/assets/javascripts/tabulator.js

@@ -2,7 +2,7 @@
 
 var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
 
-/* Tabulator v3.3.3 (c) Oliver Folkerd */
+/* Tabulator v3.4.0 (c) Oliver Folkerd */
 
 /*
  * This file is part of the Tabulator package.
@@ -570,9 +570,9 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
         this.table.options.columnMoved(from.getComponent(), this.table.columnManager.getComponents());
       }
 
-      if (this.table.options.persistentLayout && this.table.extExists("persistentLayout", true)) {
+      if (this.table.options.persistentLayout && this.table.extExists("persistence", true)) {
 
-        this.table.extensions.persistentLayout.save();
+        this.table.extensions.persistence.save("columns");
       }
     };
 
@@ -615,6 +615,23 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
       }
     };
 
+    ColumnManager.prototype.scrollToColumn = function (column) {
+
+      var left;
+
+      if (column.visible) {
+
+        left = column.element.position().left + this.element.scrollLeft() + column.element.innerWidth() - this.headersElement.innerWidth();
+
+        this.table.rowManager.scrollHorizontal(left);
+
+        this.scrollHorizontal(left);
+      } else {
+
+        console.warn("Scroll Error - Column not visible");
+      }
+    };
+
     //////////////// Cell Management /////////////////
 
 
@@ -801,9 +818,9 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       if (force) {
 
-        if (this.table.options.persistentLayout && this.table.extExists("persistentLayout", true)) {
+        if (this.table.options.persistentLayout && this.table.extExists("persistence", true)) {
 
-          this.table.extensions.persistentLayout.save();
+          this.table.extensions.persistence.save("columns");
         }
 
         if (this.table.extExists("columnCalcs")) {
@@ -887,6 +904,11 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
       return this.column;
     };
 
+    ColumnComponent.prototype.scrollTo = function () {
+
+      this.column.table.columManager.scrollToColumn(this.column);
+    };
+
     var Column = function Column(def, parent) {
 
       var self = this;
@@ -1269,6 +1291,23 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
         self.cellEvents.cellTapHold = def.cellTapHold;
       }
+
+      //setup column cell edit callbacks
+
+      if (typeof def.cellEdited == "function") {
+
+        self.cellEvents.cellEdited = def.cellEdited;
+      }
+
+      if (typeof def.cellEditing == "function") {
+
+        self.cellEvents.cellEditing = def.cellEditing;
+      }
+
+      if (typeof def.cellEditCancelled == "function") {
+
+        self.cellEvents.cellEditCancelled = def.cellEditCancelled;
+      }
     };
 
     //build header element for header
@@ -1556,12 +1595,15 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
     Column.prototype.verticalAlign = function (alignment) {
 
-      if (this.parent.isGroup) {
+      //calculate height of column header and group holder element
 
-        this.element.css("height", this.parent.getGroupElement().innerHeight());
-      } else {
+      var parentHeight = this.parent.isGroup ? this.parent.getGroupElement().innerHeight() : this.parent.getHeadersElement().innerHeight();
+
+      this.element.css("height", parentHeight);
+
+      if (this.isGroup) {
 
-        this.element.css("height", this.parent.getHeadersElement().innerHeight());
+        this.groupElement.css("min-height", parentHeight - this.contentElement.outerHeight());
       }
 
       //vertically align cell contents
@@ -1591,6 +1633,8 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       this.element.css("height", "");
 
+      this.element.css("min-height", "");
+
       this.columns.forEach(function (column) {
 
         column.clearVerticalAlign();
@@ -1757,9 +1801,9 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
           cell.show();
         });
 
-        if (this.table.options.persistentLayout && this.table.extExists("persistentLayout", true)) {
+        if (this.table.options.persistentLayout && this.table.extExists("persistence", true)) {
 
-          this.table.extensions.persistentLayout.save();
+          this.table.extensions.persistence.save("columns");
         }
 
         this.table.options.groupVisibilityChanged(this.getComponent(), true);
@@ -1792,9 +1836,9 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
           cell.hide();
         });
 
-        if (this.table.options.persistentLayout && this.table.extExists("persistentLayout", true)) {
+        if (this.table.options.persistentLayout && this.table.extExists("persistence", true)) {
 
-          this.table.extensions.persistentLayout.save();
+          this.table.extensions.persistence.save("columns");
         }
 
         this.table.options.groupVisibilityChanged(this.getComponent(), false);
@@ -1928,18 +1972,32 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
       return cell;
     };
 
-    Column.prototype.reinitializeWidth = function () {
+    Column.prototype.reinitializeWidth = function (force) {
 
       this.widthFixed = false;
 
       //set width if present
 
-      if (typeof this.definition.width !== "undefined") {
+      if (typeof this.definition.width !== "undefined" && !force) {
 
         this.setWidth(this.definition.width);
       }
 
+      //hide header filters to prevent them altering column width
+
+      if (this.table.extExists("filter")) {
+
+        this.table.extensions.filter.hideHeaderFilterElements();
+      }
+
       this.fitToData();
+
+      //show header filters again after layout is complete
+
+      if (this.table.extExists("filter")) {
+
+        this.table.extensions.filter.showHeaderFilterElements();
+      }
     };
 
     //set column width to maximum cell width
@@ -2087,6 +2145,19 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
       return this.tableElement;
     };
 
+    //return position of row in table
+
+    RowManager.prototype.getRowPosition = function (row, active) {
+
+      if (active) {
+
+        return this.activeRows.indexOf(row);
+      } else {
+
+        return this.rows.indexOf(row);
+      }
+    };
+
     //link to column manager
 
     RowManager.prototype.setColumnManager = function (manager) {
@@ -2132,7 +2203,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       //handle virtual dom scrolling
 
-      if (self.table.options.height && self.table.options.virtualDom) {
+      if (self.table.options.virtualDom) {
 
         self.element.scroll(function () {
 
@@ -2203,6 +2274,17 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
       return false;
     };
 
+    RowManager.prototype.getRowFromPosition = function (position, active) {
+
+      if (active) {
+
+        return this.activeRows[position];
+      } else {
+
+        return this.rows[position];
+      }
+    };
+
     RowManager.prototype.scrollToRow = function (row) {
 
       var rowIndex;
@@ -2241,6 +2323,11 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       self.table.options.dataLoading(data);
 
+      self.rows.forEach(function (row) {
+
+        row.wipe();
+      });
+
       self.rows = [];
 
       if (this.table.options.history && this.table.extExists("history")) {
@@ -2305,13 +2392,19 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
         this.refreshActiveData();
       } else {
 
-        this.renderTable();
+        if (this.table.options.groupBy && this.table.extExists("groupRows")) {
+
+          this.table.extensions.groupRows.updateGroupRows(true);
+        } else {
+
+          this.reRenderInPosition();
+        }
       }
     };
 
-    RowManager.prototype.addRow = function (data, pos, index) {
+    RowManager.prototype.addRow = function (data, pos, index, blockRedraw) {
 
-      var row = this.addRowActual(data, pos, index);
+      var row = this.addRowActual(data, pos, index, blockRedraw);
 
       if (this.table.options.history && this.table.extExists("history")) {
 
@@ -2326,6 +2419,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
     RowManager.prototype.addRows = function (data, pos, index) {
 
       var self = this,
+          length = 0,
           rows = [];
 
       pos = this.findAddRowPos(pos);
@@ -2335,18 +2429,35 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
         data = [data];
       }
 
+      length = data.length - 1;
+
       if (typeof index == "undefined" && pos || typeof index !== "undefined" && !pos) {
 
         data.reverse();
       }
 
-      data.forEach(function (item) {
+      data.forEach(function (item, i) {
 
-        var row = self.addRow(item, pos, index);
+        var row = self.addRow(item, pos, index, true);
 
         rows.push(row.getComponent());
       });
 
+      if (this.table.options.groupBy && this.table.extExists("groupRows")) {
+
+        this.table.extensions.groupRows.updateGroupRows(true);
+      } else {
+
+        this.reRenderInPosition();
+      }
+
+      //recalc column calculations if present
+
+      if (this.table.extExists("columnCalcs")) {
+
+        this.table.extensions.columnCalcs.recalc(this.table.rowManager.displayRows);
+      }
+
       return rows;
     };
 
@@ -2370,10 +2481,9 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
       return pos;
     };
 
-    RowManager.prototype.addRowActual = function (data, pos, index) {
+    RowManager.prototype.addRowActual = function (data, pos, index, blockRedraw) {
 
-      var safeData = data || {},
-          row = new Row(safeData, this),
+      var row = new Row(data || {}, this),
           top = this.findAddRowPos(pos);
 
       if (index) {
@@ -2381,6 +2491,40 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
         index = this.findRow(index);
       }
 
+      if (this.table.options.groupBy && this.table.extExists("groupRows")) {
+
+        this.table.extensions.groupRows.assignRowToGroup(row);
+
+        var groupRows = row.getGroup().rows;
+
+        if (groupRows.length > 1) {
+
+          if (!index || index && groupRows.indexOf(index) == -1) {
+
+            if (top) {
+
+              if (groupRows[0] !== row) {
+
+                index = groupRows[0];
+
+                this._moveRowInArray(row.getGroup().rows, row, index, top);
+              }
+            } else {
+
+              if (groupRows[groupRows.length - 1] !== row) {
+
+                index = groupRows[groupRows.length - 1];
+
+                this._moveRowInArray(row.getGroup().rows, row, index, top);
+              }
+            }
+          } else {
+
+            this._moveRowInArray(row.getGroup().rows, row, index, top);
+          }
+        }
+      };
+
       if (index) {
 
         var allIndex = this.rows.indexOf(index),
@@ -2428,63 +2572,98 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       this.table.options.dataEdited(this.getData());
 
-      this.renderTable();
+      if (!blockRedraw) {
+
+        this.reRenderInPosition();
+      }
 
       return row;
     };
 
     RowManager.prototype.moveRow = function (from, to, after) {
 
+      if (this.table.options.history && this.table.extExists("history")) {
+
+        this.table.extensions.history.action("rowMoved", from, { pos: this.getRowPosition(from), to: to, after: after });
+      };
+
+      this.moveRowActual(from, to, after);
+
+      this.table.options.rowMoved(from.getComponent());
+    };
+
+    RowManager.prototype.moveRowActual = function (from, to, after) {
+
       this._moveRowInArray(this.rows, from, to, after);
 
       this._moveRowInArray(this.activeRows, from, to, after);
 
       this._moveRowInArray(this.displayRows, from, to, after);
 
-      this.table.options.rowMoved(from.getComponent());
+      if (this.table.options.groupBy && this.table.extExists("groupRows")) {
+
+        var toGroup = to.getGroup();
+
+        var fromGroup = from.getGroup();
+
+        if (toGroup === fromGroup) {
+
+          this._moveRowInArray(toGroup.rows, from, to, after);
+        } else {
+
+          if (fromGroup) {
+
+            fromGroup.removeRow(from);
+          }
+
+          toGroup.insertRow(from, to, after);
+        }
+      }
     };
 
     RowManager.prototype._moveRowInArray = function (rows, from, to, after) {
 
-      var fromIndex = rows.indexOf(from),
-          toIndex,
-          start,
-          end;
+      var fromIndex, toIndex, start, end;
 
-      if (fromIndex > -1) {
+      if (from !== to) {
 
-        rows.splice(fromIndex, 1);
+        fromIndex = rows.indexOf(from);
 
-        toIndex = rows.indexOf(to);
+        if (fromIndex > -1) {
 
-        if (toIndex > -1) {
+          rows.splice(fromIndex, 1);
 
-          if (after) {
+          toIndex = rows.indexOf(to);
+
+          if (toIndex > -1) {
+
+            if (after) {
 
-            rows.splice(toIndex + 1, 0, from);
+              rows.splice(toIndex + 1, 0, from);
+            } else {
+
+              rows.splice(toIndex, 0, from);
+            }
           } else {
 
-            rows.splice(toIndex, 0, from);
+            rows.splice(fromIndex, 0, from);
           }
-        } else {
-
-          rows.splice(fromIndex, 0, from);
         }
-      }
 
-      //restyle rows
+        //restyle rows
 
-      if (rows === this.displayRows) {
+        if (rows === this.displayRows) {
 
-        start = fromIndex < toIndex ? fromIndex : toIndex;
+          start = fromIndex < toIndex ? fromIndex : toIndex;
 
-        end = toIndex > fromIndex ? toIndex : fromIndex + 1;
+          end = toIndex > fromIndex ? toIndex : fromIndex + 1;
 
-        for (var i = start; i <= end; i++) {
+          for (var i = start; i <= end; i++) {
 
-          if (rows[i]) {
+            if (rows[i]) {
 
-            this.styleRow(rows[i], i);
+              this.styleRow(rows[i], i);
+            }
           }
         }
       }
@@ -2579,7 +2758,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
         var def = column.getDefinition();
 
-        if (column.getVisibility()) {
+        if (column.getVisibility() && !def.hideInHtml) {
 
           header += '<th>' + (def.title || "") + '</th>';
         }
@@ -2812,6 +2991,11 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
       if (self.element.is(":visible")) {
 
         self.renderTable();
+
+        if (table.options.layoutColumnsOnNewData) {
+
+          self.table.columnManager.redraw(true);
+        }
       }
 
       if (table.extExists("columnCalcs")) {
@@ -2831,6 +3015,11 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       this.displayRows = displayRows;
 
+      if (this.table.extExists("frozenRows")) {
+
+        this.table.extensions.frozenRows.filterFrozenRows();
+      }
+
       this.displayRowsCount = this.displayRows.length;
     };
 
@@ -2844,6 +3033,40 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
     ///////////////// Table Rendering /////////////////
 
 
+    //trigger rerender of table in current position
+
+    RowManager.prototype.reRenderInPosition = function (rowCount) {
+
+      if (this.getRenderMode() == "virtual") {
+
+        var scrollTop = this.element.scrollTop();
+
+        var topRow = false;
+
+        var topOffset = false;
+
+        for (var i = this.vDomTop; i <= this.vDomBottom; i++) {
+
+          if (this.displayRows[i]) {
+
+            var diff = scrollTop - this.displayRows[i].getElement().position().top;
+
+            if (topOffset === false || Math.abs(diff) < topOffset) {
+
+              topOffset = diff;
+
+              topRow = i;
+            }
+          }
+        }
+
+        this._virtualRenderFill(topRow === false ? this.displayRows.length - 1 : topRow, true, topOffset || 0);
+      } else {
+
+        this.renderTable();
+      }
+    };
+
     RowManager.prototype.renderTable = function () {
 
       var self = this;
@@ -2991,7 +3214,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
     //full virtual render
 
-    RowManager.prototype._virtualRenderFill = function (position, forceMove) {
+    RowManager.prototype._virtualRenderFill = function (position, forceMove, offset) {
 
       var self = this,
           element = self.tableElement,
@@ -3083,7 +3306,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
           self.vDomScrollHeight = topPadHeight + rowsHeight + self.vDomBottomPad - self.height;
         } else {
 
-          self.vDomTopPad = !forceMove ? self.scrollTop - topPadHeight : self.vDomRowHeight * this.vDomTop + topPadHeight;
+          self.vDomTopPad = !forceMove ? self.scrollTop - topPadHeight : self.vDomRowHeight * this.vDomTop + offset;
 
           self.vDomBottomPad = self.vDomBottom == self.displayRowsCount - 1 ? 0 : Math.max(self.vDomScrollHeight - self.vDomTopPad - rowsHeight - topPadHeight, 0);
         }
@@ -3094,7 +3317,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
         if (forceMove) {
 
-          this.scrollTop = self.vDomTopPad + topPadHeight;
+          this.scrollTop = self.vDomTopPad + topPadHeight + offset;
         }
 
         this.scrollTop = Math.min(this.scrollTop, this.element[0].scrollHeight - this.height);
@@ -3222,7 +3445,12 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
           if (this.vDomTopPad < 0) {
 
-            this.vDomTopPad = (this.vDomTop - 1) * this.vDomRowHeight;
+            this.vDomTopPad = index * this.vDomRowHeight;
+          }
+
+          if (!index) {
+
+            this.vDomTopPad = 0;
           }
 
           table[0].style.paddingTop = this.vDomTopPad + "px";
@@ -3388,24 +3616,21 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       var self = this;
 
-      if (self.table.options.height) {
-
-        var otherHeigt = self.columnManager.getElement().outerHeight() + (self.table.footerManager ? self.table.footerManager.getElement().outerHeight() : 0);
+      var otherHeight = self.columnManager.getElement().outerHeight() + (self.table.footerManager ? self.table.footerManager.getElement().outerHeight() : 0);
 
-        self.element.css({
+      self.element.css({
 
-          "min-height": "calc(100% - " + otherHeigt + "px)",
+        "min-height": "calc(100% - " + otherHeight + "px)",
 
-          "height": "calc(100% - " + otherHeigt + "px)",
+        "height": "calc(100% - " + otherHeight + "px)",
 
-          "max-height": "calc(100% - " + otherHeigt + "px)"
+        "max-height": "calc(100% - " + otherHeight + "px)"
 
-        });
+      });
 
-        self.height = self.element.innerHeight();
+      self.height = self.element.innerHeight();
 
-        self.vDomWindowBuffer = self.table.options.virtualDomBuffer || self.height;
-      }
+      self.vDomWindowBuffer = self.table.options.virtualDomBuffer || self.height;
     };
 
     //renitialize all rows
@@ -3422,7 +3647,8 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
     RowManager.prototype.redraw = function (force) {
 
-      var pos = 0;
+      var pos = 0,
+          left = this.scrollLeft;
 
       if (this.renderMode == "virtual") {
 
@@ -3439,6 +3665,8 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
           var pos = Math.floor(this.element.scrollTop() / this.element[0].scrollHeight * this.displayRowsCount);
 
           this._virtualRenderFill(pos);
+
+          this.scrollHorizontal(left);
         }
 
         if (!this.displayRowsCount) {
@@ -3502,6 +3730,11 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
       return this.row.getData(true)[this.row.table.options.index];
     };
 
+    RowComponent.prototype.getPosition = function (active) {
+
+      return this.row.table.rowManager.getRowPosition(this.row, active);
+    };
+
     RowComponent.prototype.delete = function () {
 
       this.row.delete();
@@ -3542,6 +3775,32 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
       return this.row;
     };
 
+    RowComponent.prototype.freeze = function () {
+
+      if (this.row.table.extExists("frozenRows", true)) {
+
+        this.row.table.extensions.frozenRows.freezeRow(this.row);
+      }
+    };
+
+    RowComponent.prototype.unfreeze = function () {
+
+      if (this.row.table.extExists("frozenRows", true)) {
+
+        this.row.table.extensions.frozenRows.unfreezeRow(this.row);
+      }
+    };
+
+    RowComponent.prototype.reformat = function () {
+
+      return this.row.reinitialize();
+    };
+
+    RowComponent.prototype.getGroup = function () {
+
+      return this.row.getGroup().getComponent();
+    };
+
     var Row = function Row(data, parent) {
 
       this.table = parent.table;
@@ -3739,6 +3998,13 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
           self.table.options.rowFormatter(self.getComponent());
         }
 
+        //set resizable handles
+
+        if (self.table.options.resizableRows && self.table.extExists("resizeRows")) {
+
+          self.table.extensions.resizeRows.initializeRow(self);
+        }
+
         self.initialized = true;
       }
     };
@@ -3812,6 +4078,13 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
       this.setCellHeight();
     };
 
+    Row.prototype.setHeight = function (height) {
+
+      this.height = height;
+
+      this.setCellHeight();
+    };
+
     //set height of rows
 
     Row.prototype.setHeight = function (height, force) {
@@ -3877,6 +4150,11 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       var self = this;
 
+      if (typeof data === "string") {
+
+        data = JSON.parse(data);
+      }
+
       //mutate incomming data if needed
 
       if (self.table.extExists("mutator")) {
@@ -4033,6 +4311,13 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       var index = this.table.rowManager.getRowIndex(this);
 
+      //deselect row if it is selected
+
+      if (this.table.extExists("selectRow")) {
+
+        this.table.extensions.selectRow._deselectRow(this.row, true);
+      }
+
       this.deleteActual();
 
       if (this.table.options.history && this.table.extExists("history")) {
@@ -4044,6 +4329,26 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
         this.table.extensions.history.action("rowDelete", this, { data: this.getData(), pos: !index, index: index });
       };
+
+      //remove from group
+
+      if (this.extensions.group) {
+
+        this.extensions.group.removeRow(this);
+      }
+
+      //recalc column calculations if present
+
+      if (this.table.extExists("columnCalcs")) {
+
+        if (this.table.options.groupBy && this.table.extExists("groupRows")) {
+
+          this.table.extensions.columnCalcs.recalcRowGroup(this);
+        } else {
+
+          this.table.extensions.columnCalcs.recalc(this.table.rowManager.displayRows);
+        }
+      }
     };
 
     Row.prototype.deleteActual = function () {
@@ -4063,6 +4368,20 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
       }
     };
 
+    Row.prototype.wipe = function () {
+
+      this.deleteCells();
+
+      this.element.empty();
+
+      this.element.remove();
+    };
+
+    Row.prototype.getGroup = function () {
+
+      return this.extensions.group || false;
+    };
+
     //////////////// Object Generation /////////////////
 
     Row.prototype.getComponent = function () {
@@ -4127,9 +4446,14 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
       this.cell.setValueActual(this.cell.getOldValue());
     };
 
-    CellComponent.prototype.edit = function () {
+    CellComponent.prototype.edit = function (force) {
+
+      return this.cell.edit(force);
+    };
+
+    CellComponent.prototype.cancelEdit = function () {
 
-      this.cell.edit();
+      this.cell.cancelEdit(force);
     };
 
     CellComponent.prototype.nav = function () {
@@ -4402,7 +4726,8 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
     Cell.prototype.setValue = function (value, mutate) {
 
-      var changed = this.setValueProcessData(value, mutate);
+      var changed = this.setValueProcessData(value, mutate),
+          component;
 
       if (changed) {
 
@@ -4411,7 +4736,14 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
           this.table.extensions.history.action("cellEdit", this, { oldValue: this.oldValue, newValue: this.value });
         };
 
-        this.table.options.cellEdited(this.getComponent());
+        component = this.getComponent();
+
+        if (this.column.cellEvents.cellEdited) {
+
+          this.column.cellEvents.cellEdited(component);
+        }
+
+        this.table.options.cellEdited(component);
 
         this.table.options.dataEdited(this.table.rowManager.getData());
       }
@@ -4535,9 +4867,28 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
       this.element[0].style.display = "none";
     };
 
-    Cell.prototype.edit = function () {
+    Cell.prototype.edit = function (force) {
+
+      if (this.table.extExists("edit", true)) {
+
+        return this.table.extensions.edit.edit(this, false, force);
+      }
+    };
+
+    Cell.prototype.cancelEdit = function () {
+
+      if (this.table.extExists("edit", true)) {
+
+        var editing = this.table.extensions.edit.getCurrentCell();
 
-      this.element.focus();
+        if (editing && editing._getSelf() === this) {
+
+          this.table.extensions.edit.cancelEdit();
+        } else {
+
+          console.warn("Cancel Editor Error - This cell is not currently being edited ");
+        }
+      }
     };
 
     Cell.prototype.delete = function () {
@@ -4791,6 +5142,8 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
         layout: "fitData", ///layout type "fitColumns" | "fitData"
 
+        layoutColumnsOnNewData: false, //update column widths on setData
+
         fitColumns: false, //DEPRICATED - fit colums to width of screen;
 
 
@@ -4801,6 +5154,10 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
         resizableColumns: true, //resizable columns
 
+        resizableRows: true, //resizable rows
+
+        autoResize: true, //auto resize table
+
 
         columns: [], //store for colum header info
 
@@ -4855,9 +5212,17 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
         virtualDom: true, //enable DOM virtualization
 
 
-        persistentLayout: false, //store cookie with column _styles
+        persistentLayout: false, //store column layout in memory
 
-        persistentLayoutID: "", //id for stored cookie
+        persistentSort: false, //store sorting in memory
+
+        persistentFilter: false, //store filters in memory
+
+        persistenceID: "", //key for persistent storage
+
+        persistenceMode: true, //mode for storing persistence information
+
+        persistentLayoutID: "", //DEPRICATED - key for persistent storage;
 
 
         responsiveLayout: false, //responsive layout flags
@@ -4949,6 +5314,8 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
         rowDeselected: function rowDeselected() {},
 
+        rowResized: function rowResized() {},
+
         //cell callbacks
 
         cellEditing: function cellEditing() {},
@@ -5035,7 +5402,13 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
         //validation has failed
 
-        validationFailed: function validationFailed() {}
+        validationFailed: function validationFailed() {},
+
+        //history callbacks
+
+        historyUndo: function historyUndo() {},
+
+        historyRedo: function historyRedo() {}
 
       },
 
@@ -5049,6 +5422,22 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
           console.warn("The%c fitColumns:true%c option has been depricated and will be removed in version 4.0, use %c layout:'fitColumns'%c instead.", "font-weight:bold;", "font-weight:regular;", "font-weight:bold;", "font-weight:regular;");
         }
+
+        if (this.options.persistentLayoutID) {
+
+          this.options.persistenceID = this.options.persistentLayoutID;
+
+          console.warn("The%c persistentLayoutID%c option has been depricated and will be removed in version 4.0, use %c persistenceID%c instead.", "font-weight:bold;", "font-weight:regular;", "font-weight:bold;", "font-weight:regular;");
+        }
+
+        if (this.options.persistentLayout === "cookie" || this.options.persistentLayout === "local") {
+
+          this.options.persistenceMode = this.options.persistentLayout;
+
+          this.options.persistentLayout = true;
+
+          console.warn("Setting the persistent storage mode on the%c persistentLayout%c option has been depricated and will be removed in version 4.0, use %c persistenceMode%c instead.", "font-weight:bold;", "font-weight:regular;", "font-weight:bold;", "font-weight:regular;");
+        }
       },
 
       //constructor
@@ -5167,11 +5556,14 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
           this.footerManager.activate();
         }
 
-        if (options.persistentLayout && this.extExists("persistentLayout", true)) {
+        if ((options.persistentLayout || options.persistentSort || options.persistentFilter) && this.extExists("persistence", true)) {
+
+          ext.persistence.initialize(options.persistenceMode, options.persistenceID);
+        }
 
-          ext.persistentLayout.initialize(options.persistentLayout, options.persistentLayoutID);
+        if (options.persistentLayout && this.extExists("persistence", true)) {
 
-          options.columns = ext.persistentLayout.load(options.columns);
+          options.columns = ext.persistence.load("columns", options.columns);
         }
 
         if (this.extExists("columnCalcs")) {
@@ -5181,9 +5573,39 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
         this.columnManager.setColumns(options.columns);
 
-        if (options.initialSort && this.extExists("sort", true)) {
+        if (this.extExists("frozenRows")) {
+
+          this.extensions.frozenRows.initialize();
+        }
+
+        if ((options.persistentSort || options.initialSort) && this.extExists("sort", true)) {
+
+          var sorters = [];
+
+          if (options.persistentSort && this.extExists("persistence", true)) {
 
-          ext.sort.setSort(options.initialSort);
+            sorters = ext.persistence.load("sort");
+
+            if (sorters === false && options.initialSort) {
+
+              sorters = options.initialSort;
+            }
+          } else if (options.initialSort) {
+
+            sorters = options.initialSort;
+          }
+
+          ext.sort.setSort(sorters);
+        }
+
+        if (options.persistentFilter && this.extExists("persistence", true)) {
+
+          var filters = ext.persistence.load("filter");
+
+          if (filters !== false) {
+
+            this.setFilter(filters);
+          }
         }
 
         if (options.pagination && this.extExists("page", true)) {
@@ -5211,6 +5633,11 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
           ext.selectRow.clearSelectionData();
         }
 
+        if (options.autoResize && this.extExists("resizeTable")) {
+
+          ext.resizeTable.initialize();
+        }
+
         options.tableBuilt();
       },
 
@@ -5419,6 +5846,11 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
         var self = this;
 
+        if (typeof data === "string") {
+
+          data = JSON.parse(data);
+        }
+
         if (data) {
 
           data.forEach(function (item) {
@@ -5438,6 +5870,11 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       addData: function addData(data, pos, index) {
 
+        if (typeof data === "string") {
+
+          data = JSON.parse(data);
+        }
+
         if (data) {
 
           this.rowManager.addRows(data, pos, index);
@@ -5453,6 +5890,11 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
         var self = this;
 
+        if (typeof data === "string") {
+
+          data = JSON.parse(data);
+        }
+
         if (data) {
 
           data.forEach(function (item) {
@@ -5464,7 +5906,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
               row.updateData(item);
             } else {
 
-              self.rowManager.addRow(item);
+              self.rowManager.addRows(item);
             }
           });
         } else {
@@ -5490,6 +5932,23 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
         }
       },
 
+      //get row object
+
+      getRowFromPosition: function getRowFromPosition(position, active) {
+
+        var row = this.rowManager.getRowFromPosition(position, active);
+
+        if (row) {
+
+          return row.getComponent();
+        } else {
+
+          console.warn("Find Error - No matching row found:", position);
+
+          return false;
+        }
+      },
+
       //delete row from table
 
       deleteRow: function deleteRow(index) {
@@ -5513,7 +5972,23 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       addRow: function addRow(data, pos, index) {
 
-        return this.rowManager.addRow(data, pos, index);
+        var row;
+
+        if (typeof data === "string") {
+
+          data = JSON.parse(data);
+        }
+
+        row = this.rowManager.addRows(data, pos, index)[0];
+
+        //recalc column calculations if present
+
+        if (this.extExists("columnCalcs")) {
+
+          this.extensions.columnCalcs.recalc(this.rowManager.displayRows);
+        }
+
+        return row;
       },
 
       //update a row if it exitsts otherwise create it
@@ -5522,12 +5997,24 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
         var row = this.rowManager.findRow(index);
 
+        if (typeof data === "string") {
+
+          data = JSON.parse(data);
+        }
+
         if (row) {
 
           row.updateData(data);
         } else {
 
-          row = this.rowManager.addRow(data);
+          row = this.rowManager.addRows(data)[0];
+
+          //recalc column calculations if present
+
+          if (this.extExists("columnCalcs")) {
+
+            this.extensions.columnCalcs.recalc(this.rowManager.displayRows);
+          }
         }
 
         return row.getComponent();
@@ -5539,6 +6026,11 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
         var row = this.rowManager.findRow(index);
 
+        if (typeof data === "string") {
+
+          data = JSON.parse(data);
+        }
+
         if (row) {
 
           row.updateData(data);
@@ -5574,6 +6066,23 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
         return this.rowManager.getComponents(active);
       },
 
+      //get position of row in table
+
+      getRowPosition: function getRowPosition(index, active) {
+
+        var row = this.rowManager.findRow(index);
+
+        if (row) {
+
+          return this.rowManager.getRowPosition(row, active);
+        } else {
+
+          console.warn("Position Error - No matching row found:", index);
+
+          return false;
+        }
+      },
+
       /////////////// Column Functions  ///////////////
 
 
@@ -5594,17 +6103,17 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       getColumnLayout: function getColumnLayout() {
 
-        if (this.extExists("persistentLayout", true)) {
+        if (this.extExists("persistence", true)) {
 
-          return this.extensions.persistentLayout.parseColumns(this.columnManager.getColumns());
+          return this.extensions.persistence.parseColumns(this.columnManager.getColumns());
         }
       },
 
       setColumnLayout: function setColumnLayout(layout) {
 
-        if (this.extExists("persistentLayout", true)) {
+        if (this.extExists("persistence", true)) {
 
-          this.columnManager.setColumns(this.extensions.persistentLayout.mergeDefinition(this.options.columns, layout));
+          this.columnManager.setColumns(this.extensions.persistence.mergeDefinition(this.options.columns, layout));
 
           return true;
         }
@@ -5685,6 +6194,23 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
         }
       },
 
+      //scroll to column in DOM
+
+      scrollToColumn: function scrollToColumn(field) {
+
+        var column = this.columnManager.findColumn(field);
+
+        if (column) {
+
+          return this.columnManager.scrollToColumn(column);
+        } else {
+
+          console.warn("Scroll Error - No matching column found:", field);
+
+          return false;
+        }
+      },
+
       //////////// Localization Functions  ////////////
 
       setLocale: function setLocale(locale) {
@@ -5810,6 +6336,42 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
         }
       },
 
+      setHeaderFilterFocus: function setHeaderFilterFocus(field) {
+
+        if (this.extExists("filter", true)) {
+
+          var column = this.columnManager.findColumn(field);
+
+          if (column) {
+
+            this.extensions.filter.setHeaderFilterFocus(column);
+          } else {
+
+            console.warn("Column Filter Focus Error - No matching column found:", field);
+
+            return false;
+          }
+        }
+      },
+
+      setHeaderFilterValue: function setHeaderFilterValue(field, value) {
+
+        if (this.extExists("filter", true)) {
+
+          var column = this.columnManager.findColumn(field);
+
+          if (column) {
+
+            this.extensions.filter.setHeaderFilterValue(column, value);
+          } else {
+
+            console.warn("Column Filter Error - No matching column found:", field);
+
+            return false;
+          }
+        }
+      },
+
       getHeaderFilters: function getHeaderFilters() {
 
         if (this.extExists("filter", true)) {
@@ -6057,6 +6619,19 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
         }
       },
 
+      ///////////////// Column Calculation Functions ///////////////
+
+      getCalcResults: function getCalcResults() {
+
+        if (this.extExists("columnCalcs", true)) {
+
+          return this.extensions.columnCalcs.getResults();
+        } else {
+
+          return false;
+        }
+      },
+
       /////////////// Navigation Management //////////////
 
 
@@ -7080,19 +7655,24 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
     Ajax.prototype.showLoader = function () {
 
-      this.loaderElement.detach();
+      var shouldLoad = typeof this.table.options.ajaxLoader === "function" ? this.table.options.ajaxLoader() : this.table.options.ajaxLoader;
 
-      this.msgElement.empty().removeClass("tabulator-error").addClass("tabulator-loading");
+      if (shouldLoad) {
 
-      if (this.loadingElement) {
+        this.loaderElement.detach();
 
-        this.msgElement.append(this.loadingElement);
-      } else {
+        this.msgElement.empty().removeClass("tabulator-error").addClass("tabulator-loading");
 
-        this.msgElement.append(this.table.extensions.localize.getText("ajax.loading"));
-      }
+        if (this.loadingElement) {
 
-      this.table.element.append(this.loaderElement);
+          this.msgElement.append(this.loadingElement);
+        } else {
+
+          this.msgElement.append(this.table.extensions.localize.getText("ajax.loading"));
+        }
+
+        this.table.element.append(this.loaderElement);
+      }
     };
 
     Ajax.prototype.showError = function () {
@@ -7294,7 +7874,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       if (!this.topInitialized) {
 
-        this.table.columnManager.element.append(this.topElement);
+        this.table.columnManager.headersElement.after(this.topElement);
 
         this.topInitialized = true;
       }
@@ -7369,26 +7949,35 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
     ColumnCalcs.prototype.recalcRowGroup = function (row) {
 
+      this.recalcGroup(this.table.extensions.groupRows.getRowGroup(row));
+    };
+
+    ColumnCalcs.prototype.recalcGroup = function (group) {
+
       var data, rowData;
 
-      var group = this.table.extensions.groupRows.getRowGroup(row);
+      if (group) {
 
-      if (group.calcs.bottom) {
+        if (group.calcs) {
 
-        data = this.rowsToData(group.rows);
+          if (group.calcs.bottom) {
 
-        rowData = this.generateRowData("bottom", data);
+            data = this.rowsToData(group.rows);
 
-        group.calcs.bottom.updateData(rowData);
-      }
+            rowData = this.generateRowData("bottom", data);
 
-      if (group.calcs.top) {
+            group.calcs.bottom.updateData(rowData);
+          }
+
+          if (group.calcs.top) {
 
-        data = this.rowsToData(group.rows);
+            data = this.rowsToData(group.rows);
 
-        rowData = this.generateRowData("top", data);
+            rowData = this.generateRowData("top", data);
 
-        group.calcs.top.updateData(rowData);
+            group.calcs.top.updateData(rowData);
+          }
+        }
       }
     };
 
@@ -7540,6 +8129,66 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
       }
     };
 
+    //return the calculated
+
+
+    ColumnCalcs.prototype.getResults = function () {
+
+      var self = this,
+          results = {},
+          groups;
+
+      if (this.table.options.groupBy && this.table.extExists("groupRows")) {
+
+        groups = this.table.extensions.groupRows.getGroups();
+
+        groups.forEach(function (group) {
+
+          results[group.getKey()] = self.getGroupResults(group);
+        });
+      } else {
+
+        results = {
+
+          top: this.topRow ? this.topRow.getData() : {},
+
+          bottom: this.botRow ? this.botRow.getData() : {}
+
+        };
+      }
+
+      return results;
+    };
+
+    //get results from a group
+
+
+    ColumnCalcs.prototype.getGroupResults = function (group) {
+
+      var self = this,
+          groupObj = group._getSelf(),
+          subGroups = group.getSubGroups(),
+          subGroupResults = {},
+          results = {};
+
+      subGroups.forEach(function (subgroup) {
+
+        subGroupResults[subgroup.getKey()] = self.getGroupResults(subgroup);
+      });
+
+      results = {
+
+        top: groupObj.calcs.top ? groupObj.calcs.top.getData() : {},
+
+        bottom: groupObj.calcs.bottom ? groupObj.calcs.bottom.getData() : {},
+
+        groups: subGroupResults
+
+      };
+
+      return results;
+    };
+
     //default calculations
 
 
@@ -7569,7 +8218,8 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       "max": function max(values, data, calcParams) {
 
-        var output = null;
+        var output = null,
+            precision = typeof calcParams.precision !== "undefined" ? calcParams.precision : false;
 
         values.forEach(function (value) {
 
@@ -7581,12 +8231,13 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
           }
         });
 
-        return output !== null ? output : "";
+        return output !== null ? precision !== false ? output.toFixed(precision) : output : "";
       },
 
       "min": function min(values, data, calcParams) {
 
-        var output = null;
+        var output = null,
+            precision = typeof calcParams.precision !== "undefined" ? calcParams.precision : false;
 
         values.forEach(function (value) {
 
@@ -7598,12 +8249,13 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
           }
         });
 
-        return output !== null ? output : "";
+        return output !== null ? precision !== false ? output.toFixed(precision) : output : "";
       },
 
       "sum": function sum(values, data, calcParams) {
 
-        var output = 0;
+        var output = 0,
+            precision = typeof calcParams.precision !== "undefined" ? calcParams.precision : false;
 
         if (values.length) {
 
@@ -7615,7 +8267,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
           });
         }
 
-        return output;
+        return precision !== false ? output.toFixed(precision) : output;
       },
 
       "concat": function concat(values, data, calcParams) {
@@ -8017,6 +8669,9 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       this.currentCell = false; //hold currently editing cell
 
+
+      this.mouseClick = false; //hold mousedown state to prevent click binding being overriden by editor opening
+
     };
 
     //initialize column editor
@@ -8094,7 +8749,9 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
       return this.currentCell ? this.currentCell.getComponent() : false;
     };
 
-    Edit.prototype.clearEditor = function (cell) {
+    Edit.prototype.clearEditor = function () {
+
+      var cell = this.currentCell;
 
       this.currentCell = false;
 
@@ -8105,15 +8762,64 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
       cell.row.getElement().removeClass("tabulator-row-editing");
     };
 
+    Edit.prototype.cancelEdit = function () {
+
+      if (this.currentCell) {
+
+        var cell = this.currentCell;
+
+        var component = this.currentCell.getComponent();
+
+        this.clearEditor();
+
+        cell.setValueActual(cell.getValue());
+
+        if (cell.column.cellEvents.cellEditCancelled) {
+
+          cell.column.cellEvents.cellEditCancelled(component);
+        }
+
+        this.table.options.cellEditCancelled(component);
+      }
+    };
+
     //return a formatted value for a cell
 
 
     Edit.prototype.bindEditor = function (cell) {
 
       var self = this,
+          element = cell.getElement();
+
+      element.attr("tabindex", 0);
+
+      element.on("click", function (e) {
+
+        if (!$(this).hasClass("tabulator-editing")) {
+
+          $(this).focus();
+        }
+      });
+
+      element.on("mousedown", function (e) {
+
+        self.mouseClick = true;
+      });
+
+      element.on("focus", function (e) {
+
+        self.edit(cell, e);
+      });
+    };
+
+    Edit.prototype.edit = function (cell, e, forceEdit) {
+
+      var self = this,
+          allowEdit = true,
           rendered = function rendered() {},
           element = cell.getElement(),
-          mouseClick = false;
+          cellEditor,
+          component;
 
       //handle successfull value change
 
@@ -8129,7 +8835,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
         if (valid === true) {
 
-          self.clearEditor(cell);
+          self.clearEditor();
 
           cell.setValue(value, true);
         } else {
@@ -8147,103 +8853,113 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       function cancel() {
 
-        self.clearEditor(cell);
-
-        cell.setValueActual(cell.getValue());
-
-        self.table.options.cellEditCancelled(cell.getComponent());
+        self.cancelEdit();
       };
 
-      element.attr("tabindex", 0);
+      function onRendered(callback) {
 
-      element.on("click", function (e) {
+        rendered = callback;
+      }
 
-        if (!$(this).hasClass("tabulator-editing")) {
+      if (!cell.column.extensions.edit.blocked) {
 
-          $(this).focus();
+        if (e) {
+
+          e.stopPropagation();
         }
-      });
 
-      element.on("mousedown", function (e) {
+        switch (_typeof(cell.column.extensions.edit.check)) {
 
-        mouseClick = true;
-      });
+          case "function":
 
-      element.on("focus", function (e) {
+            allowEdit = cell.column.extensions.edit.check(cell.getComponent());
 
-        var allowEdit = true,
-            cellEditor;
+            break;
+
+          case "boolean":
 
-        self.currentCell = cell;
+            allowEdit = cell.column.extensions.edit.check;
 
-        function onRendered(callback) {
+            break;
 
-          rendered = callback;
         }
 
-        if (!cell.column.extensions.edit.blocked) {
+        if (allowEdit || forceEdit) {
 
-          e.stopPropagation();
-
-          if (typeof cell.column.extensions.edit.check == "function") {
+          self.cancelEdit();
 
-            allowEdit = cell.column.extensions.edit.check(cell.getComponent());
-          }
+          self.currentCell = cell;
 
-          if (allowEdit) {
+          component = cell.getComponent();
 
-            if (mouseClick) {
+          if (this.mouseClick) {
 
-              mouseClick = false;
+            this.mouseClick = false;
 
-              if (cell.column.cellEvents.cellClick) {
+            if (cell.column.cellEvents.cellClick) {
 
-                cell.column.cellEvents.cellClick(e, cell.getComponent());
-              }
+              cell.column.cellEvents.cellClick(component);
             }
+          }
 
-            self.table.options.cellEditing(cell.getComponent());
+          if (cell.column.cellEvents.cellEditing) {
 
-            cellEditor = cell.column.extensions.edit.editor.call(self, cell.getComponent(), onRendered, success, cancel, cell.column.extensions.edit.params);
+            cell.column.cellEvents.cellEditing(component);
+          }
 
-            //if editor returned, add to DOM, if false, abort edit
+          self.table.options.cellEditing(component);
 
+          cellEditor = cell.column.extensions.edit.editor.call(self, component, onRendered, success, cancel, cell.column.extensions.edit.params);
 
-            if (cellEditor !== false) {
+          //if editor returned, add to DOM, if false, abort edit
 
-              element.addClass("tabulator-editing");
 
-              cell.row.getElement().addClass("tabulator-row-editing");
+          if (cellEditor !== false) {
 
-              element.empty();
+            element.addClass("tabulator-editing");
 
-              element.append(cellEditor);
+            cell.row.getElement().addClass("tabulator-row-editing");
 
-              //trigger onRendered Callback
+            element.empty();
 
+            element.append(cellEditor);
 
-              rendered();
+            //trigger onRendered Callback
 
-              //prevent editing from triggering rowClick event
 
+            rendered();
 
-              element.children().click(function (e) {
+            //prevent editing from triggering rowClick event
 
-                e.stopPropagation();
-              });
-            } else {
 
-              element.blur();
-            }
+            element.children().click(function (e) {
+
+              e.stopPropagation();
+            });
           } else {
 
             element.blur();
+
+            return false;
           }
+
+          return true;
         } else {
 
+          this.mouseClick = false;
+
           element.blur();
+
+          return false;
         }
-      });
+      } else {
+
+        this.mouseClick = false;
+
+        element.blur();
+
+        return false;
+      }
     };
 
     //default data editors
@@ -8402,7 +9118,98 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       number: function number(cell, onRendered, success, cancel, editorParams) {
 
-        var input = $("<input type='number'/>");
+        var max = typeof editorParams.max != "undefined" ? "max='" + editorParams.max + "'" : "";
+
+        var min = typeof editorParams.min != "undefined" ? "min='" + editorParams.min + "'" : "";
+
+        var step = "step='" + (typeof editorParams.step != "undefined" ? editorParams.step : 1) + "'";
+
+        var input = $("<input type='number' " + max + " " + min + " " + step + "/>");
+
+        //create and style input
+
+
+        input.css({
+
+          "padding": "4px",
+
+          "width": "100%",
+
+          "box-sizing": "border-box"
+
+        }).val(cell.getValue());
+
+        onRendered(function () {
+
+          input.css("height", "100%");
+
+          setTimeout(function () {
+
+            input.focus();
+          }, 10);
+        });
+
+        //submit new value on blur
+
+
+        input.on("blur", function (e) {
+
+          var value = input.val();
+
+          if (!isNaN(value)) {
+
+            value = Number(value);
+          }
+
+          if (value != cell.getValue()) {
+
+            success(value);
+          } else {
+
+            cancel();
+          }
+        });
+
+        //submit new value on enter
+
+
+        input.on("keydown", function (e) {
+
+          var value;
+
+          if (e.keyCode == 13) {
+
+            value = input.val();
+
+            if (!isNaN(value)) {
+
+              value = Number(value);
+            }
+
+            success(value);
+          }
+
+          if (e.keyCode == 27) {
+
+            cancel();
+          }
+        });
+
+        return input;
+      },
+
+      //input element with type of number
+
+
+      range: function range(cell, onRendered, success, cancel, editorParams) {
+
+        var max = "max='" + (typeof editorParams.max != "undefined" ? editorParams.max : 10) + "'";
+
+        var min = "min='" + (typeof editorParams.min != "undefined" ? editorParams.min : 0) + "'";
+
+        var step = "step='" + (typeof editorParams.step != "undefined" ? editorParams.step : 1) + "'";
+
+        var input = $("<input type='range' " + max + " " + min + " " + step + "/>");
 
         //create and style input
 
@@ -8476,6 +9283,110 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
         return input;
       },
 
+      //select
+
+
+      select: function select(cell, onRendered, success, cancel, editorParams) {
+
+        //create and style select
+
+
+        var select = $("<select><select/>");
+
+        var isArray = Array.isArray(editorParams);
+
+        if (typeof editorParams == "function") {
+
+          editorParams = editorParams(cell);
+
+          isArray = Array.isArray(editorParams);
+        }
+
+        function optionAppend(element, label, value, disabled) {
+
+          var option = $("<option></option>").attr("value", value).text(label);
+
+          if (disabled) {
+
+            option.prop("disabled", true);
+          }
+
+          element.append(option);
+        }
+
+        function processOption(element, option) {
+
+          var groupEl;
+
+          if (option.options) {
+
+            groupEl = $("<optgroup></optgroup>").attr("label", option.label);
+
+            option.options.forEach(function (item) {
+
+              processOption(groupEl, item);
+            });
+
+            element.append(groupEl);
+          } else {
+
+            optionAppend(element, typeof option.label == "undefined" ? option.value : option.label, typeof option.value == "undefined" ? option.label : option.value, option.disabled);
+          }
+        }
+
+        if (!isArray && (typeof editorParams === 'undefined' ? 'undefined' : _typeof(editorParams)) === "object") {
+
+          for (var key in editorParams) {
+
+            optionAppend(select, editorParams[key], key);
+          }
+        } else if (isArray) {
+
+          editorParams.forEach(function (item) {
+
+            processOption(select, item);
+          });
+        }
+
+        select.css({
+
+          "padding": "4px",
+
+          "width": "100%",
+
+          "box-sizing": "border-box",
+
+          "font-family": ""
+
+        }).val(cell.getValue());
+
+        onRendered(function () {
+
+          select.focus().click();
+        });
+
+        //submit new value on blur
+
+
+        select.on("change blur", function (e) {
+
+          success(select.val());
+        });
+
+        //submit new value on enter
+
+
+        select.on("keydown", function (e) {
+
+          if (e.keyCode === 13) {
+
+            success(select.val());
+          }
+        });
+
+        return select;
+      },
+
       //start rating
 
 
@@ -8972,6 +9883,12 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
         self.table.rowManager.filterRefresh();
       };
 
+      column.extensions.filter = {
+
+        success: success
+
+      };
+
       //handle aborted edit
 
 
@@ -9103,6 +10020,8 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
             }, 300);
           });
 
+          column.extensions.filter.headerElement = editorElement;
+
           //update number filtered columns on change
 
 
@@ -9152,6 +10071,61 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
       }
     };
 
+    //hide all header filter elements (used to ensure correct column widths in "fitData" layout mode)
+
+
+    Filter.prototype.hideHeaderFilterElements = function () {
+
+      this.headerFilterElements.forEach(function (element) {
+
+        element.hide();
+      });
+    };
+
+    //show all header filter elements (used to ensure correct column widths in "fitData" layout mode)
+
+
+    Filter.prototype.showHeaderFilterElements = function () {
+
+      this.headerFilterElements.forEach(function (element) {
+
+        element.show();
+      });
+    };
+
+    //programatically set value of header filter
+
+
+    Filter.prototype.setHeaderFilterFocus = function (column) {
+
+      if (column.extensions.filter && column.extensions.filter.headerElement) {
+
+        column.extensions.filter.headerElement.focus();
+      } else {
+
+        console.warn("Column Filter Focus Error - No header filter set on column:", column.getField());
+      }
+    };
+
+    //programatically set value of header filter
+
+
+    Filter.prototype.setHeaderFilterValue = function (column, value) {
+
+      if (column) {
+
+        if (column.extensions.filter && column.extensions.filter.headerElement) {
+
+          column.extensions.filter.headerElement.val(value);
+
+          column.extensions.filter.success(value);
+        } else {
+
+          console.warn("Column Filter Error - No header filter set on column:", column.getField());
+        }
+      }
+    };
+
     //check if the filters has changed since last use
 
 
@@ -9240,6 +10214,11 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
           self.changed = true;
         }
       });
+
+      if (this.table.options.persistentFilter && this.table.extExists("persistence", true)) {
+
+        this.table.extensions.persistence.save("filter");
+      }
     };
 
     //get all filters
@@ -9330,6 +10309,11 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
           console.warn("Filter Error - No matching filter type found, ignoring: ", filter.type);
         }
       });
+
+      if (this.table.options.persistentFilter && this.table.extExists("persistence", true)) {
+
+        this.table.extensions.persistence.save("filter");
+      }
     };
 
     //clear filters
@@ -9345,6 +10329,11 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
       }
 
       this.changed = true;
+
+      if (this.table.options.persistentFilter && this.table.extExists("persistence", true)) {
+
+        this.table.extensions.persistence.save("filter");
+      }
     };
 
     //clear header filters
@@ -9498,6 +10487,22 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
           return rowVal.toLowerCase().indexOf(filterVal.toLowerCase()) > -1 ? true : false;
         }
+      },
+
+      //in array
+
+
+      "in": function _in(filterVal, rowVal) {
+
+        if (Array.isArray(filterVal)) {
+
+          return filterVal.indexOf(rowVal) > -1;
+        } else {
+
+          console.warn("Filter Error - filter value is not an array:", filterVal);
+
+          return false;
+        }
       }
 
     };
@@ -9528,6 +10533,11 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
           if (self.formatters[column.definition.formatter]) {
 
             config.formatter = self.formatters[column.definition.formatter];
+
+            if (column.definition.formatter === "email") {
+
+              console.warn("The%c email%c formatter has been depricated and will be removed in version 4.0, use the %clink %cformatter with %cformatterParams:{urlPrefix:'mailto:'} %cinstead.", "font-weight:bold;", "font-weight:regular;", "font-weight:bold;", "font-weight:regular;", "font-weight:bold;", "font-weight:regular;");
+            }
           } else {
 
             console.warn("Formatter Error - No such formatter found: ", column.definition.formatter);
@@ -9731,27 +10741,89 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       link: function link(cell, formatterParams) {
 
-        var value = this.sanitizeHTML(cell.getValue());
+        var value = this.sanitizeHTML(cell.getValue()),
+            urlPrefix = formatterParams.urlPrefix || "",
+            label = this.emptyToSpace(value),
+            data;
 
-        return "<a href='" + value + "'>" + this.emptyToSpace(value) + "</a>";
-      },
+        if (formatterParams.labelField) {
 
-      //image element
+          data = cell.getData();
 
+          label = data[formatterParams.labelField];
+        }
 
-      image: function image(cell, formatterParams) {
+        if (formatterParams.label) {
 
-        var value = this.sanitizeHTML(cell.getValue());
+          switch (_typeof(formatterParams.label)) {
 
-        return "<img src='" + value + "'/>";
-      },
+            case "string":
 
-      //tick or empty cell
+              label = formatterParams.label;
 
+              break;
 
-      tick: function tick(cell, formatterParams) {
+            case "function":
 
-        var value = cell.getValue(),
+              label = formatterParams.label(cell);
+
+              break;
+
+          }
+        }
+
+        if (formatterParams.urlField) {
+
+          data = cell.getData();
+
+          value = data[formatterParams.urlField];
+        }
+
+        if (formatterParams.url) {
+
+          switch (_typeof(formatterParams.url)) {
+
+            case "string":
+
+              value = formatterParams.url;
+
+              break;
+
+            case "function":
+
+              value = formatterParams.url(cell);
+
+              break;
+
+          }
+        }
+
+        return "<a href='" + urlPrefix + value + "'>" + label + "</a>";
+      },
+
+      //image element
+
+
+      image: function image(cell, formatterParams) {
+
+        var value = this.sanitizeHTML(cell.getValue());
+
+        var el = $("<img src='" + value + "'/>");
+
+        el.on("load", function () {
+
+          cell.getRow().normalizeHeight();
+        });
+
+        return el;
+      },
+
+      //tick or empty cell
+
+
+      tick: function tick(cell, formatterParams) {
+
+        var value = cell.getValue(),
             element = cell.getElement();
 
         var tick = '<svg enable-background="new 0 0 24 24" height="14" width="14" viewBox="0 0 24 24" xml:space="preserve" ><path fill="#2DC214" clip-rule="evenodd" d="M21.652,3.211c-0.293-0.295-0.77-0.295-1.061,0L9.41,14.34  c-0.293,0.297-0.771,0.297-1.062,0L3.449,9.351C3.304,9.203,3.114,9.13,2.923,9.129C2.73,9.128,2.534,9.201,2.387,9.351  l-2.165,1.946C0.078,11.445,0,11.63,0,11.823c0,0.194,0.078,0.397,0.223,0.544l4.94,5.184c0.292,0.296,0.771,0.776,1.062,1.07  l2.124,2.141c0.292,0.293,0.769,0.293,1.062,0l14.366-14.34c0.293-0.294,0.293-0.777,0-1.071L21.652,3.211z" fill-rule="evenodd"/></svg>';
@@ -9792,6 +10864,23 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
         }
       },
 
+      //select
+
+
+      lookup: function lookup(cell, formatterParams) {
+
+        var value = cell.getValue();
+
+        if (typeof formatterParams[value] === "undefined") {
+
+          console.warn('Missing display value for ' + value);
+
+          return value;
+        }
+
+        return formatterParams[value];
+      },
+
       //star rating
 
 
@@ -9839,22 +10928,130 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
             element = cell.getElement(),
             max = formatterParams && formatterParams.max ? formatterParams.max : 100,
             min = formatterParams && formatterParams.min ? formatterParams.min : 0,
-            color = formatterParams && formatterParams.color ? formatterParams.color : "#2DC214",
-            percent;
+            percent,
+            percentValue,
+            color,
+            legend,
+            legendColor;
 
         //make sure value is in range
 
 
-        value = parseFloat(value) <= max ? parseFloat(value) : max;
+        percentValue = parseFloat(value) <= max ? parseFloat(value) : max;
 
-        value = parseFloat(value) >= min ? parseFloat(value) : min;
+        percentValue = parseFloat(percentValue) >= min ? parseFloat(percentValue) : min;
 
         //workout percentage
 
 
         percent = (max - min) / 100;
 
-        value = 100 - Math.round((value - min) / percent);
+        percentValue = 100 - Math.round((percentValue - min) / percent);
+
+        //set bar color
+
+
+        switch (_typeof(formatterParams.color)) {
+
+          case "string":
+
+            color = formatterParams.color;
+
+            break;
+
+          case "function":
+
+            color = formatterParams.color(value);
+
+            break;
+
+          case "object":
+
+            if (Array.isArray(formatterParams.color)) {
+
+              var unit = 100 / formatterParams.color.length;
+
+              var index = Math.floor(percentValue / unit);
+
+              index = Math.min(index, formatterParams.color.length - 1);
+
+              color = formatterParams.color[formatterParams.color.length - 1 - index];
+
+              break;
+            }
+
+          default:
+
+            color = "#2DC214";
+
+        }
+
+        //generate legend
+
+
+        switch (_typeof(formatterParams.legend)) {
+
+          case "string":
+
+            legend = formatterParams.legend;
+
+            break;
+
+          case "function":
+
+            legend = formatterParams.legend(value);
+
+            break;
+
+          case "boolean":
+
+            legend = value;
+
+            break;
+
+          default:
+
+            legend = false;
+
+        }
+
+        //set legend color
+
+
+        switch (_typeof(formatterParams.legendColor)) {
+
+          case "string":
+
+            legendColor = formatterParams.legendColor;
+
+            break;
+
+          case "function":
+
+            legendColor = formatterParams.legendColor(value);
+
+            break;
+
+          case "object":
+
+            if (Array.isArray(formatterParams.legendColor)) {
+
+              var unit = 100 / formatterParams.legendColor.length;
+
+              var index = Math.floor(percentValue / unit);
+
+              index = Math.min(index, formatterParams.legendColor.length - 1);
+
+              legendColor = formatterParams.legendColor[formatterParams.legendColor.length - 1 - index];
+
+              break;
+            }
+
+          default:
+
+            legendColor = "#000";
+
+        }
 
         element.css({
 
@@ -9864,9 +11061,9 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
         });
 
-        element.attr("aria-label", value);
+        element.attr("aria-label", percentValue);
 
-        return "<div style='position:absolute; top:8px; bottom:8px; left:4px; right:" + value + "%; margin-right:4px; background-color:" + color + "; display:inline-block;' data-max='" + max + "' data-min='" + min + "'></div>";
+        return "<div style='position:absolute; top:8px; bottom:8px; left:4px; right:" + percentValue + "%; margin-right:4px; background-color:" + color + "; display:inline-block;' data-max='" + max + "' data-min='" + min + "'></div>" + (legend ? "<div style='position:absolute; top:4px; left:0; text-align:center; width:100%; color:" + legendColor + ";'>" + legend + "</div>" : "");
       },
 
       //background color
@@ -10137,6 +11334,101 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
     Tabulator.registerExtension("frozenColumns", FrozenColumns);
 
+    var FrozenRows = function FrozenRows(table) {
+
+      this.table = table; //hold Tabulator object
+
+
+      this.topElement = $("<div class='tabulator-frozen-rows-holder'></div>");
+
+      this.rows = [];
+    };
+
+    FrozenRows.prototype.initialize = function () {
+
+      this.rows = [];
+
+      this.table.columnManager.element.append(this.topElement);
+    };
+
+    FrozenRows.prototype.filterFrozenRows = function () {
+
+      var self = this,
+          frozen = [];
+
+      self.table.rowManager.displayRows.forEach(function (row, i) {
+
+        if (row.extensions.frozen == true) {
+
+          frozen.unshift(i);
+        }
+      });
+
+      frozen.forEach(function (index) {
+
+        self.table.rowManager.displayRows.splice(index, 1);
+      });
+    };
+
+    FrozenRows.prototype.freezeRow = function (row) {
+
+      if (!row.extensions.frozen) {
+
+        row.extensions.frozen = true;
+
+        this.topElement.append(row.getElement());
+
+        this.table.rowManager.adjustTableSize();
+
+        this.table.rowManager.refreshActiveData();
+
+        this.rows.push(row);
+
+        this.styleRows();
+      } else {
+
+        console.warn("Freeze Error - Row is already frozen");
+      }
+    };
+
+    FrozenRows.prototype.unfreezeRow = function (row) {
+
+      var index = this.rows.indexOf(row);
+
+      if (row.extensions.frozen) {
+
+        row.extensions.frozen = false;
+
+        row.getElement().detach();
+
+        this.table.rowManager.adjustTableSize();
+
+        this.table.rowManager.refreshActiveData();
+
+        this.rows.splice(index, 1);
+
+        if (this.rows.length) {
+
+          this.styleRows();
+        }
+      } else {
+
+        console.warn("Freeze Error - Row is already unfrozen");
+      }
+    };
+
+    FrozenRows.prototype.styleRows = function (row) {
+
+      var self = this;
+
+      this.rows.forEach(function (row, i) {
+
+        self.table.rowManager.styleRow(row, i);
+      });
+    };
+
+    Tabulator.registerExtension("frozenRows", FrozenRows);
+
     //public group object
 
 
@@ -10220,7 +11512,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
     //////////////////////////////////////////////////
 
 
-    var Group = function Group(groupManager, parent, level, key, generator, oldGroup) {
+    var Group = function Group(groupManager, parent, level, key, field, generator, oldGroup) {
 
       this.groupManager = groupManager;
 
@@ -10230,6 +11522,8 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       this.level = level;
 
+      this.field = field;
+
       this.hasSubGroups = level < groupManager.groupIDLookups.length - 1;
 
       this.addRow = this.hasSubGroups ? this._addRowToGroup : this._addRow;
@@ -10249,7 +11543,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       this.element = $("<div class='tabulator-row tabulator-group tabulator-group-level-" + level + "' role='rowgroup'></div>");
 
-      this.arrowElement = $("<div class='tabulator-arrow'></div>");
+      this.elementContents = $(""), this.arrowElement = $("<div class='tabulator-arrow'></div>");
 
       this.height = 0;
 
@@ -10261,6 +11555,8 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       this.initialized = false;
 
+      this.extensions = {};
+
       this.visible = oldGroup ? oldGroup.visible : typeof groupManager.startOpen[level] !== "undefined" ? groupManager.startOpen[level] : groupManager.startOpen[0];
 
       this.addBindings();
@@ -10274,20 +11570,6 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
           tap,
           toggleElement;
 
-      if (self.groupManager.table.options.groupToggleElement) {
-
-        toggleElement = self.groupManager.table.options.groupToggleElement == "arrow" ? self.arrowElement : self.element;
-
-        toggleElement.on("click", function (e) {
-
-          e.stopPropagation();
-
-          e.stopImmediatePropagation();
-
-          self.toggleVisibility();
-        });
-      }
-
       //handle group click events
 
 
@@ -10387,6 +11669,20 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
           tapHold = null;
         });
       }
+
+      if (self.groupManager.table.options.groupToggleElement) {
+
+        toggleElement = self.groupManager.table.options.groupToggleElement == "arrow" ? self.arrowElement : self.element;
+
+        toggleElement.on("click", function (e) {
+
+          e.stopPropagation();
+
+          e.stopImmediatePropagation();
+
+          self.toggleVisibility();
+        });
+      }
     };
 
     Group.prototype._addRowToGroup = function (row) {
@@ -10395,11 +11691,11 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       if (this.hasSubGroups) {
 
-        var groupID = this.groupManager.groupIDLookups[level](row.getData());
+        var groupID = this.groupManager.groupIDLookups[level].func(row.getData());
 
         if (!this.groups[groupID]) {
 
-          var group = new Group(this.groupManager, this, level, groupID, this.groupManager.headerGenerator[level] || this.groupManager.headerGenerator[0], this.old ? this.old.groups[groupID] : false);
+          var group = new Group(this.groupManager, this, level, groupID, this.groupManager.groupIDLookups[level].field, this.groupManager.headerGenerator[level] || this.groupManager.headerGenerator[0], this.old ? this.old.groups[groupID] : false);
 
           this.groups[groupID] = group;
 
@@ -10413,6 +11709,122 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
     Group.prototype._addRow = function (row) {
 
       this.rows.push(row);
+
+      row.extensions.group = this;
+    };
+
+    Group.prototype.insertRow = function (row, to, after) {
+
+      var data = this.conformRowData({});
+
+      row.updateData(data);
+
+      var toIndex = this.rows.indexOf(to);
+
+      if (toIndex > -1) {
+
+        if (after) {
+
+          this.rows.splice(toIndex + 1, 0, row);
+        } else {
+
+          this.rows.splice(toIndex, 0, row);
+        }
+      } else {
+
+        if (after) {
+
+          this.rows.push(row);
+        } else {
+
+          this.rows.unshift(row);
+        }
+      }
+
+      row.extensions.group = this;
+
+      this.generateGroupHeaderContents();
+
+      if (this.groupManager.table.extExists("columnCalcs")) {
+
+        this.groupManager.table.extensions.columnCalcs.recalcGroup(this);
+      }
+    };
+
+    Group.prototype.getRowIndex = function (row) {};
+
+    //update row data to match grouping contraints
+
+
+    Group.prototype.conformRowData = function (data) {
+
+      if (this.field) {
+
+        data[this.field] = this.key;
+      } else {
+
+        console.warn("Data Conforming Error - Cannot conform row data to match new group as groupBy is a function");
+      }
+
+      if (this.parent) {
+
+        data = this.parent.conformRowData(data);
+      }
+
+      return data;
+    };
+
+    Group.prototype.removeRow = function (row) {
+
+      var index = this.rows.indexOf(row);
+
+      if (index > -1) {
+
+        this.rows.splice(index, 1);
+      }
+
+      if (!this.rows.length) {
+
+        if (this.parent) {
+
+          this.parent.removeGroup(this);
+        } else {
+
+          this.groupManager.removeGroup(this);
+        }
+
+        this.groupManager.updateGroupRows(true);
+      } else {
+
+        this.generateGroupHeaderContents();
+
+        if (this.groupManager.table.extExists("columnCalcs")) {
+
+          this.groupManager.table.extensions.columnCalcs.recalcGroup(this);
+        }
+      }
+    };
+
+    Group.prototype.removeGroup = function (group) {
+
+      var index;
+
+      if (this.groups[group.key]) {
+
+        delete this.groups[group.key];
+
+        index = this.groupList.indexOf(group);
+
+        if (index > -1) {
+
+          this.groupList.splice(index, 1);
+        }
+
+        if (!this.groupList.length) {
+
+          this.parent.removeGroup();
+        }
+      }
     };
 
     Group.prototype.getHeadersAndRows = function () {
@@ -10599,21 +12011,28 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
       return match;
     };
 
-    ////////////// Standard Row Functions //////////////
+    Group.prototype.generateGroupHeaderContents = function () {
 
+      var data = [];
 
-    Group.prototype.getElement = function () {
+      this.rows.forEach(function (row) {
 
-      this.addBindingsd = false;
+        data.push(row.getData());
+      });
 
-      this._visSet();
+      this.elementContents = this.generator(this.key, this.getRowCount(), data, this.getComponent());
 
-      var data = [];
+      this.element.empty().append(this.elementContents).prepend(this.arrowElement);
+    };
 
-      this.rows.forEach(function (row) {
+    ////////////// Standard Row Functions //////////////
+
+
+    Group.prototype.getElement = function () {
+
+      this.addBindingsd = false;
 
-        data.push(row.getData());
-      });
+      this._visSet();
 
       if (this.visible) {
 
@@ -10625,7 +12044,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       this.element.children().detach();
 
-      this.element.html(this.generator(this.key, this.getRowCount(), data, this.getComponent())).prepend(this.arrowElement);
+      this.generateGroupHeaderContents();
 
       // this.addBindings();
 
@@ -10681,6 +12100,11 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
       return this.outerHeight;
     };
 
+    Group.prototype.getGroup = function () {
+
+      return this;
+    };
+
     Group.prototype.reinitializeHeight = function () {};
 
     Group.prototype.calcHeight = function () {};
@@ -10755,7 +12179,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
           //header layout function
 
 
-          return value + "<span>(" + count + " " + (count === 1 ? langValue : lang.groups.items) + ")</span>";
+          return (typeof value === "undefined" ? "" : value) + "<span>(" + count + " " + (count === 1 ? langValue : lang.groups.items) + ")</span>";
         };
       });
 
@@ -10819,7 +12243,13 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
           }
         }
 
-        self.groupIDLookups.push(lookupFunc);
+        self.groupIDLookups.push({
+
+          field: typeof group === "function" ? false : group,
+
+          func: lookupFunc
+
+        });
       });
 
       if (startOpen) {
@@ -10874,13 +12304,10 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       var groupComponents = [];
 
-      if (this.table.options.dataGrouped) {
-
-        this.groupList.forEach(function (group) {
+      this.groupList.forEach(function (group) {
 
-          groupComponents.push(group.getComponent());
-        });
-      }
+        groupComponents.push(group.getComponent());
+      });
 
       return groupComponents;
     };
@@ -10918,19 +12345,28 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       rows.forEach(function (row) {
 
-        var groupID = self.groupIDLookups[0](row.getData());
+        self.assignRowToGroup(row, oldGroups);
+      });
+    };
 
-        if (!self.groups[groupID]) {
+    GroupRows.prototype.assignRowToGroup = function (row, oldGroups) {
 
-          var group = new Group(self, false, 0, groupID, self.headerGenerator[0], oldGroups[groupID]);
+      var groupID = this.groupIDLookups[0].func(row.getData()),
+          oldGroups = oldGroups || [],
+          newGroupNeeded = !this.groups[groupID];
 
-          self.groups[groupID] = group;
+      if (newGroupNeeded) {
 
-          self.groupList.push(group);
-        }
+        var group = new Group(this, false, 0, groupID, this.groupIDLookups[0].field, this.headerGenerator[0], oldGroups[groupID]);
 
-        self.groups[groupID].addRow(row);
-      });
+        this.groups[groupID] = group;
+
+        this.groupList.push(group);
+      }
+
+      this.groups[groupID].addRow(row);
+
+      return !newGroupNeeded;
     };
 
     GroupRows.prototype.updateGroupRows = function (force) {
@@ -10949,11 +12385,9 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       if (force) {
 
-        oldRowCount = self.table.rowManager.displayRowsCount;
-
         self.table.rowManager.setDisplayRows(output);
 
-        self.table.rowManager._virtualRenderFill(Math.floor(self.table.rowManager.element.scrollTop() / self.table.rowManager.element[0].scrollHeight * oldRowCount));
+        self.table.rowManager.reRenderInPosition();
       }
 
       return output;
@@ -10967,6 +12401,23 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
       });
     };
 
+    GroupRows.prototype.removeGroup = function (group) {
+
+      var index;
+
+      if (this.groups[group.key]) {
+
+        delete this.groups[group.key];
+
+        index = this.groupList.indexOf(group);
+
+        if (index > -1) {
+
+          this.groupList.splice(index, 1);
+        }
+      }
+    };
+
     Tabulator.registerExtension("groupRows", GroupRows);
 
     var History = function History(table) {
@@ -10988,10 +12439,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
     History.prototype.action = function (type, component, data) {
 
-      if (this.index > -1) {
-
-        this.history = this.history.slice(0, this.index + 1);
-      }
+      this.history = this.history.slice(0, this.index + 1);
 
       this.history.push({
 
@@ -11016,6 +12464,8 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
         this.index--;
 
+        this.table.options.historyUndo(action.type, action.component, action.data);
+
         return true;
       } else {
 
@@ -11035,6 +12485,8 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
         this.redoers[action.type].call(this, action);
 
+        this.table.options.historyRedo(action.type, action.component, action.data);
+
         return true;
       } else {
 
@@ -11061,6 +12513,13 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
         var newRow = this.table.rowManager.addRowActual(action.data.data, action.data.pos, action.data.index);
 
         this._rebindRow(action.component, newRow);
+      },
+
+      rowMoved: function rowMoved(action) {
+
+        this.table.rowManager.moveRowActual(action.component, this.table.rowManager.rows[action.data.pos], false);
+
+        this.table.rowManager.redraw();
       }
 
     };
@@ -11082,6 +12541,13 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
       rowDelete: function rowDelete(action) {
 
         action.component.delete();
+      },
+
+      rowMoved: function rowMoved(action) {
+
+        this.table.rowManager.moveRowActual(action.component, action.data.to, action.data.after);
+
+        this.table.rowManager.redraw();
       }
 
     };
@@ -12430,13 +13896,13 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       this.pagesElement = $("<span class='tabulator-pages'></span>");
 
-      this.firstBut = $("<button class='tabulator-page' data-page='first' role='button' aria-label='' title=''></button>");
+      this.firstBut = $("<button class='tabulator-page' data-page='first' role='button' aria-label='' title='' type='button'></button>");
 
-      this.prevBut = $("<button class='tabulator-page' data-page='prev' role='button' aria-label='' title=''></button>");
+      this.prevBut = $("<button class='tabulator-page' data-page='prev' role='button' aria-label='' title='' type='button'></button>");
 
-      this.nextBut = $("<button class='tabulator-page' data-page='next' role='button' aria-label='' title=''></button>");
+      this.nextBut = $("<button class='tabulator-page' data-page='next' role='button' aria-label='' title='' type='button'></button>");
 
-      this.lastBut = $("<button class='tabulator-page' data-page='last' role='button' aria-label='' title=''></button>");
+      this.lastBut = $("<button class='tabulator-page' data-page='last' role='button' aria-label='' title='' type='button'></button>");
 
       this.mode = "local";
 
@@ -13003,7 +14469,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
     Tabulator.registerExtension("page", Page);
 
-    var PersistentLayout = function PersistentLayout(table) {
+    var Persistence = function Persistence(table) {
 
       this.table = table; //hold Tabulator object
 
@@ -13018,7 +14484,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
     //setup parameters
 
 
-    PersistentLayout.prototype.initialize = function (mode, id) {
+    Persistence.prototype.initialize = function (mode, id) {
 
       //determine persistent layout storage type
 
@@ -13034,15 +14500,31 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
     //load saved definitions
 
 
-    PersistentLayout.prototype.load = function (definition) {
+    Persistence.prototype.load = function (type, current) {
+
+      var data = this.retreiveData(type);
+
+      if (current) {
+
+        data = data ? this.mergeDefinition(current, data) : current;
+      }
+
+      return data;
+    };
+
+    //retreive data from memory
+
 
-      var newDefinition = "";
+    Persistence.prototype.retreiveData = function (type) {
+
+      var data = "",
+          id = this.id + (type === "columns" ? "" : "-" + type);
 
       switch (this.mode) {
 
         case "local":
 
-          newDefinition = localStorage.getItem(this.id);
+          data = localStorage.getItem(id);
 
           break;
 
@@ -13052,7 +14534,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
 
           var cookie = document.cookie,
-              cookiePos = cookie.indexOf(this.id + "="),
+              cookiePos = cookie.indexOf(id + "="),
               end = void 0;
 
           //if cookie exists, decode and load column data into tabulator
@@ -13069,7 +14551,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
               cookie = cookie.substr(0, end);
             }
 
-            newDefinition = cookie.replace(this.id + "=", "");
+            data = cookie.replace(id + "=", "");
           }
 
           break;
@@ -13080,24 +14562,22 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       }
 
-      if (newDefinition) {
-
-        newDefinition = JSON.parse(newDefinition);
-
-        definition = this.mergeDefinition(definition, newDefinition);
-      }
-
-      return definition;
+      return data ? JSON.parse(data) : false;
     };
 
     //merge old and new column defintions
 
 
-    PersistentLayout.prototype.mergeDefinition = function (oldCols, newCols) {
+    Persistence.prototype.mergeDefinition = function (oldCols, newCols) {
 
       var self = this,
           output = [];
 
+      // oldCols = oldCols || [];
+
+
+      newCols = newCols || [];
+
       newCols.forEach(function (column, to) {
 
         var from = self._findColumn(oldCols, column);
@@ -13123,7 +14603,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
     //find matching columns
 
 
-    PersistentLayout.prototype._findColumn = function (columns, subject) {
+    Persistence.prototype._findColumn = function (columns, subject) {
 
       var type = subject.columns ? "group" : subject.field ? "field" : "object";
 
@@ -13153,19 +14633,67 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
       });
     };
 
-    //save current definitions
+    //save data
+
+
+    Persistence.prototype.save = function (type) {
+
+      var data = {};
+
+      switch (type) {
+
+        case "columns":
+
+          data = this.parseColumns(this.table.columnManager.getColumns());
+
+          break;
+
+        case "filter":
+
+          data = this.table.extensions.filter.getFilters();
+
+          break;
+
+        case "sort":
+
+          data = this.validateSorters(this.table.extensions.sort.getSort());
+
+          break;
+
+      }
+
+      var id = this.id + (type === "columns" ? "" : "-" + type);
+
+      this.saveData(id, data);
+    };
+
+    //ensure sorters contain no function data
+
+
+    Persistence.prototype.validateSorters = function (data) {
+
+      data.forEach(function (item) {
+
+        item.column = item.field;
+
+        delete item.field;
+      });
+
+      return data;
+    };
+
+    //save data to chosed medium
 
 
-    PersistentLayout.prototype.save = function () {
+    Persistence.prototype.saveData = function (id, data) {
 
-      var definition = this.parseColumns(this.table.columnManager.getColumns()),
-          data = JSON.stringify(definition);
+      data = JSON.stringify(data);
 
       switch (this.mode) {
 
         case "local":
 
-          localStorage.setItem(this.id, data);
+          localStorage.setItem(id, data);
 
           break;
 
@@ -13178,7 +14706,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
           //save cookie
 
 
-          document.cookie = this.id + "=" + data + "; expires=" + expireDate.toUTCString();
+          document.cookie = id + "=" + data + "; expires=" + expireDate.toUTCString();
 
           break;
 
@@ -13192,7 +14720,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
     //build premission list
 
 
-    PersistentLayout.prototype.parseColumns = function (columns) {
+    Persistence.prototype.parseColumns = function (columns) {
 
       var self = this,
           definitions = [];
@@ -13223,7 +14751,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
       return definitions;
     };
 
-    Tabulator.registerExtension("persistentLayout", PersistentLayout);
+    Tabulator.registerExtension("persistence", Persistence);
 
     var ResizeColumns = function ResizeColumns(table) {
 
@@ -13276,45 +14804,214 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
           var nearestColumn = column.getLastColumn();
 
-          if (nearestColumn) {
+          if (nearestColumn) {
+
+            self.startColumn = column;
+
+            self._mouseDown(e, nearestColumn);
+          }
+        });
+
+        handle.addEventListener("mousedown", function (e) {
+
+          var nearestColumn = column.getLastColumn();
+
+          if (nearestColumn) {
+
+            self.startColumn = column;
+
+            self._mouseDown(e, nearestColumn);
+          }
+        });
+
+        //reszie column on  double click
+
+
+        handle.addEventListener("dblclick", function (e) {
+
+          column.reinitializeWidth(true);
+        });
+
+        prevHandle.addEventListener("click", function (e) {
+
+          e.stopPropagation();
+        });
+
+        prevHandle.addEventListener("mousedown", function (e) {
+
+          var nearestColumn, colIndex, prevColumn;
+
+          nearestColumn = column.getFirstColumn();
+
+          if (nearestColumn) {
+
+            colIndex = self.table.columnManager.findColumnIndex(nearestColumn);
+
+            prevColumn = colIndex > 0 ? self.table.columnManager.getColumnByIndex(colIndex - 1) : false;
+
+            if (prevColumn) {
+
+              self.startColumn = column;
+
+              self._mouseDown(e, prevColumn);
+            }
+          }
+        });
+
+        //resize column on double click
+
+
+        prevHandle.addEventListener("dblclick", function (e) {
+
+          var nearestColumn, colIndex, prevColumn;
+
+          nearestColumn = column.getFirstColumn();
+
+          if (nearestColumn) {
+
+            colIndex = self.table.columnManager.findColumnIndex(nearestColumn);
+
+            prevColumn = colIndex > 0 ? self.table.columnManager.getColumnByIndex(colIndex - 1) : false;
+
+            if (prevColumn) {
+
+              prevColumn.reinitializeWidth(true);
+            }
+          }
+        });
+
+        element.append(handle).append(prevHandle);
+      }
+    };
+
+    ResizeColumns.prototype._mouseDown = function (e, column) {
+
+      var self = this;
+
+      self.table.element.addClass("tabulator-block-select");
+
+      function mouseMove(e) {
+
+        column.setWidth(self.startWidth + (e.screenX - self.startX));
+
+        if (!self.table.browserSlow && column.extensions.resize && column.extensions.resize.variableHeight) {
+
+          column.checkCellHeights();
+        }
+      }
+
+      function mouseUp(e) {
+
+        //block editor from taking action while resizing is taking place
+
+
+        if (self.startColumn.extensions.edit) {
+
+          self.startColumn.extensions.edit.blocked = false;
+        }
+
+        if (self.table.browserSlow && column.extensions.resize && column.extensions.resize.variableHeight) {
+
+          column.checkCellHeights();
+        }
+
+        $("body").off("mouseup", mouseMove);
+
+        $("body").off("mousemove", mouseMove);
+
+        self.table.element.removeClass("tabulator-block-select");
+
+        if (self.table.options.persistentLayout && self.table.extExists("persistence", true)) {
+
+          self.table.extensions.persistence.save("columns");
+        }
+
+        self.table.options.columnResized(self.startColumn.getComponent());
+      }
+
+      e.stopPropagation(); //prevent resize from interfereing with movable columns
+
+
+      //block editor from taking action while resizing is taking place
+
+
+      if (self.startColumn.extensions.edit) {
+
+        self.startColumn.extensions.edit.blocked = true;
+      }
+
+      self.startX = e.screenX;
+
+      self.startWidth = column.getWidth();
+
+      $("body").on("mousemove", mouseMove);
+
+      $("body").on("mouseup", mouseUp);
+    };
+
+    Tabulator.registerExtension("resizeColumns", ResizeColumns);
+
+    var ResizeRows = function ResizeRows(table) {
+
+      this.table = table; //hold Tabulator object
+
+
+      this.startColumn = false;
+
+      this.startY = false;
+
+      this.startHeight = false;
+
+      this.handle = null;
+
+      this.prevHandle = null;
+    };
+
+    ResizeRows.prototype.initializeRow = function (row) {
+
+      var self = this;
+
+      var handle = document.createElement('div');
+
+      handle.className = "tabulator-row-resize-handle";
+
+      var prevHandle = document.createElement('div');
 
-            self.startColumn = column;
+      prevHandle.className = "tabulator-row-resize-handle prev";
 
-            self._mouseDown(e, nearestColumn);
-          }
-        });
+      handle.addEventListener("click", function (e) {
 
-        prevHandle.addEventListener("click", function (e) {
+        e.stopPropagation();
+      });
 
-          e.stopPropagation();
-        });
+      handle.addEventListener("mousedown", function (e) {
 
-        prevHandle.addEventListener("mousedown", function (e) {
+        self.startRow = row;
 
-          var nearestColumn, colIndex, prevColumn;
+        self._mouseDown(e, row);
+      });
 
-          nearestColumn = column.getFirstColumn();
+      prevHandle.addEventListener("click", function (e) {
 
-          if (nearestColumn) {
+        e.stopPropagation();
+      });
 
-            colIndex = self.table.columnManager.findColumnIndex(nearestColumn);
+      prevHandle.addEventListener("mousedown", function (e) {
 
-            prevColumn = colIndex > 0 ? self.table.columnManager.getColumnByIndex(colIndex - 1) : false;
+        var prevRow = self.table.rowManager.prevDisplayRow(row);
 
-            if (prevColumn) {
+        if (prevRow) {
 
-              self.startColumn = column;
+          self.startRow = prevRow;
 
-              self._mouseDown(e, prevColumn);
-            }
-          }
-        });
+          self._mouseDown(e, prevRow);
+        }
+      });
 
-        element.append(handle).append(prevHandle);
-      }
+      row.getElement().append(handle).append(prevHandle);
     };
 
-    ResizeColumns.prototype._mouseDown = function (e, column) {
+    ResizeRows.prototype._mouseDown = function (e, row) {
 
       var self = this;
 
@@ -13322,28 +15019,22 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       function mouseMove(e) {
 
-        column.setWidth(self.startWidth + (e.screenX - self.startX));
-
-        if (!self.table.browserSlow && column.extensions.resize && column.extensions.resize.variableHeight) {
-
-          column.checkCellHeights();
-        }
+        row.setHeight(self.startHeight + (e.screenY - self.startY));
       }
 
       function mouseUp(e) {
 
-        //block editor from taking action while resizing is taking place
+        // //block editor from taking action while resizing is taking place
 
 
-        if (self.startColumn.extensions.edit) {
+        // if(self.startColumn.extensions.edit){
 
-          self.startColumn.extensions.edit.blocked = false;
-        }
 
-        if (self.table.browserSlow && column.extensions.resize && column.extensions.resize.variableHeight) {
+        // 	self.startColumn.extensions.edit.blocked = false;
+
+
+        // }
 
-          column.checkCellHeights();
-        }
 
         $("body").off("mouseup", mouseMove);
 
@@ -13351,12 +15042,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
         self.table.element.removeClass("tabulator-block-select");
 
-        if (self.table.options.persistentLayout && self.table.extExists("persistentLayout", true)) {
-
-          self.table.extensions.persistentLayout.save();
-        }
-
-        self.table.options.columnResized(self.startColumn.getComponent());
+        self.table.options.rowResized(row.getComponent());
       }
 
       e.stopPropagation(); //prevent resize from interfereing with movable columns
@@ -13365,21 +15051,55 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
       //block editor from taking action while resizing is taking place
 
 
-      if (self.startColumn.extensions.edit) {
+      // if(self.startColumn.extensions.edit){
 
-        self.startColumn.extensions.edit.blocked = true;
-      }
 
-      self.startX = e.screenX;
+      // 	self.startColumn.extensions.edit.blocked = true;
 
-      self.startWidth = column.getWidth();
+
+      // }
+
+
+      self.startY = e.screenY;
+
+      self.startHeight = row.getHeight();
 
       $("body").on("mousemove", mouseMove);
 
       $("body").on("mouseup", mouseUp);
     };
 
-    Tabulator.registerExtension("resizeColumns", ResizeColumns);
+    Tabulator.registerExtension("resizeRows", ResizeRows);
+
+    var ResizeTable = function ResizeTable(table) {
+
+      this.table = table; //hold Tabulator object
+
+    };
+
+    ResizeTable.prototype.initialize = function (row) {
+
+      var table = this.table,
+          observer;
+
+      if (typeof ResizeObserver !== "undefined") {
+
+        observer = new ResizeObserver(function (entry) {
+
+          table.redraw();
+        });
+
+        observer.observe(table.element[0]);
+      } else {
+
+        $(window).resize(function () {
+
+          $(".tabulator").tabulator("redraw");
+        });
+      }
+    };
+
+    Tabulator.registerExtension("resizeTable", ResizeTable);
 
     var ResponsiveLayout = function ResponsiveLayout(table) {
 
@@ -13633,7 +15353,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
           self.table.rowManager.rows.forEach(function (row) {
 
-            self._selectRow(row, true, true);
+            self._selectRow(row, false, true);
           });
 
           self._rowSelectionChanged();
@@ -13646,7 +15366,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
             self.table.rowManager.activeRows.forEach(function (row) {
 
-              self._selectRow(row, true, true);
+              self._selectRow(row, false, true);
             });
 
             self._rowSelectionChanged();
@@ -13660,7 +15380,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
             rows.forEach(function (row) {
 
-              self._selectRow(row, true);
+              self._selectRow(row);
             });
 
             self._rowSelectionChanged();
@@ -13691,7 +15411,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
           if (self.table.options.selectableRollingSelection) {
 
-            self._deselectRow(self.selectedRows[0], true);
+            self._deselectRow(self.selectedRows[0]);
           } else {
 
             return false;
@@ -13719,7 +15439,10 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
         }
       } else {
 
-        console.warn("Selection Error - No such row found, ignoring selection:" + rowInfo);
+        if (!silent) {
+
+          console.warn("Selection Error - No such row found, ignoring selection:" + rowInfo);
+        }
       }
     };
 
@@ -13746,7 +15469,7 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
           rows.forEach(function (row) {
 
-            self._deselectRow(row, true);
+            self._deselectRow(row);
           });
 
           self._rowSelectionChanged();
@@ -13790,7 +15513,10 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
         }
       } else {
 
-        console.warn("Selection Error - No such row found, ignoring selection:" + rowInfo);
+        if (!silent) {
+
+          console.warn("Deselection Error - No such row found, ignoring selection:" + rowInfo);
+        }
       }
     };
 
@@ -13995,6 +15721,11 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
       });
 
       self.sortList = newSortList;
+
+      if (this.table.options.persistentSort && this.table.extExists("persistence", true)) {
+
+        this.table.extensions.persistence.save("sort");
+      }
     };
 
     //clear sorters
@@ -14203,7 +15934,27 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       number: function number(a, b, aRow, bRow, column, dir, params) {
 
-        return parseFloat(String(a).replace(",", "")) - parseFloat(String(b).replace(",", ""));
+        var a = parseFloat(String(a).replace(",", ""));
+
+        var b = parseFloat(String(b).replace(",", ""));
+
+        //handle non numeric values
+
+
+        if (isNaN(a)) {
+
+          return -1;
+
+          if (isNaN(b)) {
+
+            return 0;
+          }
+        } else if (isNaN(b)) {
+
+          return 1;
+        }
+
+        return a - b;
       },
 
       //sort strings
@@ -14211,7 +15962,28 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
       string: function string(a, b, aRow, bRow, column, dir, params) {
 
-        return String(a).toLowerCase().localeCompare(String(b).toLowerCase());
+        var locale;
+
+        switch (_typeof(params.locale)) {
+
+          case "boolean":
+
+            if (params.locale) {
+
+              local = this.table.extensions.localize.getLocale();
+            }
+
+            break;
+
+          case "string":
+
+            locale = params.locale;
+
+            break;
+
+        }
+
+        return String(a).toLowerCase().localeCompare(String(b).toLowerCase(), locale);
       },
 
       //sort date
@@ -14228,6 +16000,48 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
           a = moment(a, format);
 
           b = moment(b, format);
+
+          if (!a.isValid()) {
+
+            a = -1000000000000000;
+          }
+
+          if (!b.isValid()) {
+
+            b = -1000000000000000;
+          }
+        } else {
+
+          console.error("Sort Error - 'date' sorter is dependant on moment.js");
+        }
+
+        return a - b;
+      },
+
+      //sort hh:mm formatted times
+
+
+      time: function time(a, b, aRow, bRow, column, dir, params) {
+
+        var self = this;
+
+        var format = params.format || "hh:mm";
+
+        if (typeof moment != "undefined") {
+
+          a = moment(a, format);
+
+          b = moment(b, format);
+
+          if (!a.isValid()) {
+
+            a = -1000000000000000;
+          }
+
+          if (!b.isValid()) {
+
+            b = -1000000000000000;
+          }
         } else {
 
           console.error("Sort Error - 'date' sorter is dependant on moment.js");
@@ -14236,6 +16050,38 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
         return a - b;
       },
 
+      //sort datetime
+
+
+      datetime: function datetime(a, b, aRow, bRow, column, dir, params) {
+
+        var self = this;
+
+        var format = params.format || "DD/MM/YYYY hh:mm:ss";
+
+        if (typeof moment != "undefined") {
+
+          a = moment(a, format);
+
+          b = moment(b, format);
+
+          if (!a.isValid()) {
+
+            a = -1000000000000000;
+          }
+
+          if (!b.isValid()) {
+
+            b = -1000000000000000;
+          }
+        } else {
+
+          console.error("Sort Error - 'datetime' sorter is dependant on moment.js");
+        }
+
+        return a - b;
+      },
+
       //sort booleans
 
 
@@ -14248,6 +16094,95 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
         return el1 - el2;
       },
 
+      //sort if element contains any data
+
+
+      array: function array(a, b, aRow, bRow, column, dir, params) {
+
+        var el1 = 0;
+
+        var el2 = 0;
+
+        var type = params.type || "length";
+
+        //handle non array values
+
+
+        if (!Array.isArray(a)) {
+
+          return -1;
+
+          if (!Array.isArray(b)) {
+
+            return 0;
+          }
+        } else if (!Array.isArray(b)) {
+
+          return 1;
+        }
+
+        function calc(value) {
+
+          switch (type) {
+
+            case "length":
+
+              return value.length;
+
+              break;
+
+            case "sum":
+
+              return value.reduce(function (c, d) {
+
+                return c + d;
+              });
+
+              break;
+
+            case "max":
+
+              return Math.max.apply(null, value);
+
+              break;
+
+            case "min":
+
+              return Math.min.apply(null, value);
+
+              break;
+
+            case "avg":
+
+              return value.reduce(function (c, d) {
+
+                return c + d;
+              }) / value.length;
+
+              break;
+
+          }
+        }
+
+        el1 = a ? calc(a) : 0;
+
+        el2 = b ? calc(b) : 0;
+
+        return el1 - el2;
+      },
+
+      //sort if element contains any data
+
+
+      exists: function exists(a, b, aRow, bRow, column, dir, params) {
+
+        var el1 = typeof a == "undefined" ? 0 : 1;
+
+        var el2 = typeof b == "undefined" ? 0 : 1;
+
+        return el1 - el2;
+      },
+
       //sort alpha numeric strings
 
 
@@ -14298,28 +16233,6 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
         }
 
         return a.length > b.length;
-      },
-
-      //sort hh:mm formatted times
-
-
-      time: function time(a, b, aRow, bRow, column, dir, params) {
-
-        var self = this;
-
-        var format = params.format || "hh:mm";
-
-        if (typeof moment != "undefined") {
-
-          a = moment(a, format);
-
-          b = moment(b, format);
-        } else {
-
-          console.error("Sort Error - 'date' sorter is dependant on moment.js");
-        }
-
-        return a - b;
       }
 
     };
@@ -14548,13 +16461,15 @@ var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol
 
         var cellData = cell.getData();
 
+        var column = cell.getColumn()._getSelf();
+
         this.table.rowManager.rows.forEach(function (row) {
 
           var data = row.getData();
 
           if (data !== cellData) {
 
-            if (value == data[cell.getField()]) {
+            if (value == column.getFieldValue(data)) {
 
               unique = false;
             }