@tabler/core 1.0.0-beta6 → 1.0.0-beta8

package/dist/js/tabler.esm.js

@@ -1,6 +1,6 @@
 /*!
-* Tabler v1.0.0-beta6 (https://tabler.io)
-* @version 1.0.0-beta6
+* Tabler v1.0.0-beta8 (https://tabler.io)
+* @version 1.0.0-beta8
 * @link https://tabler.io
 * Copyright 2018-2022 The Tabler Authors
 * Copyright 2018-2022 codecalm.net Paweł Kuna
@@ -17,16 +17,11 @@ if (elements.length) {
 
 function _typeof(obj) {
   "@babel/helpers - typeof";
-  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
-    _typeof = function (obj) {
-      return typeof obj;
-    };
-  } else {
-    _typeof = function (obj) {
-      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-    };
-  }
-  return _typeof(obj);
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  }, _typeof(obj);
 }
 function _classCallCheck(instance, Constructor) {
   if (!(instance instanceof Constructor)) {
@@ -45,6 +40,9 @@ function _defineProperties(target, props) {
 function _createClass(Constructor, protoProps, staticProps) {
   if (protoProps) _defineProperties(Constructor.prototype, protoProps);
   if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
   return Constructor;
 }
 function _defineProperty(obj, key, value) {
@@ -71,6 +69,9 @@ function _inherits(subClass, superClass) {
       configurable: true
     }
   });
+  Object.defineProperty(subClass, "prototype", {
+    writable: false
+  });
   if (superClass) _setPrototypeOf(subClass, superClass);
 }
 function _getPrototypeOf(o) {
@@ -159,7 +160,7 @@ function _superPropBase(object, property) {
   }
   return object;
 }
-function _get(target, property, receiver) {
+function _get() {
   if (typeof Reflect !== "undefined" && Reflect.get) {
     _get = Reflect.get;
   } else {
@@ -168,12 +169,12 @@ function _get(target, property, receiver) {
       if (!base) return;
       var desc = Object.getOwnPropertyDescriptor(base, property);
       if (desc.get) {
-        return desc.get.call(receiver);
+        return desc.get.call(arguments.length < 3 ? target : receiver);
       }
       return desc.value;
     };
   }
-  return _get(target, property, receiver || target);
+  return _get.apply(this, arguments);
 }
 function set(target, property, value, receiver) {
   if (typeof Reflect !== "undefined" && Reflect.set) {
@@ -260,6 +261,34 @@ function _nonIterableRest() {
   throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
 
+var ChangeDetails = function () {
+  function ChangeDetails(details) {
+    _classCallCheck(this, ChangeDetails);
+    Object.assign(this, {
+      inserted: '',
+      rawInserted: '',
+      skip: false,
+      tailShift: 0
+    }, details);
+  }
+  _createClass(ChangeDetails, [{
+    key: "aggregate",
+    value: function aggregate(details) {
+      this.rawInserted += details.rawInserted;
+      this.skip = this.skip || details.skip;
+      this.inserted += details.inserted;
+      this.tailShift += details.tailShift;
+      return this;
+    }
+  }, {
+    key: "offset",
+    get: function get() {
+      return this.tailShift + this.inserted.length;
+    }
+  }]);
+  return ChangeDetails;
+}();
+
 function isString(str) {
   return typeof str === 'string' || str instanceof String;
 }
@@ -283,6 +312,9 @@ function forceDirection(direction) {
 function escapeRegExp(str) {
   return str.replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
 }
+function normalizePrepare(prep) {
+  return Array.isArray(prep) ? prep : [prep, new ChangeDetails()];
+}
 function objectIncludes(b, a) {
   if (a === b) return true;
   var arrA = Array.isArray(a),
@@ -370,40 +402,13 @@ var ActionDetails = function () {
     key: "removeDirection",
     get: function get() {
       if (!this.removedCount || this.insertedCount) return DIRECTION.NONE;
-      return this.oldSelection.end === this.cursorPos || this.oldSelection.start === this.cursorPos ? DIRECTION.RIGHT : DIRECTION.LEFT;
+      return (this.oldSelection.end === this.cursorPos || this.oldSelection.start === this.cursorPos) &&
+      this.oldSelection.end === this.oldSelection.start ? DIRECTION.RIGHT : DIRECTION.LEFT;
     }
   }]);
   return ActionDetails;
 }();
 
-var ChangeDetails = function () {
-  function ChangeDetails(details) {
-    _classCallCheck(this, ChangeDetails);
-    Object.assign(this, {
-      inserted: '',
-      rawInserted: '',
-      skip: false,
-      tailShift: 0
-    }, details);
-  }
-  _createClass(ChangeDetails, [{
-    key: "aggregate",
-    value: function aggregate(details) {
-      this.rawInserted += details.rawInserted;
-      this.skip = this.skip || details.skip;
-      this.inserted += details.inserted;
-      this.tailShift += details.tailShift;
-      return this;
-    }
-  }, {
-    key: "offset",
-    get: function get() {
-      return this.tailShift + this.inserted.length;
-    }
-  }]);
-  return ChangeDetails;
-}();
-
 var ContinuousTailDetails = function () {
   function ContinuousTailDetails() {
     var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
@@ -444,13 +449,21 @@ var ContinuousTailDetails = function () {
       Object.assign(this, state);
     }
   }, {
-    key: "shiftBefore",
-    value: function shiftBefore(pos) {
-      if (this.from >= pos || !this.value.length) return '';
+    key: "unshift",
+    value: function unshift(beforePos) {
+      if (!this.value.length || beforePos != null && this.from >= beforePos) return '';
       var shiftChar = this.value[0];
       this.value = this.value.slice(1);
       return shiftChar;
     }
+  }, {
+    key: "shift",
+    value: function shift() {
+      if (!this.value.length) return '';
+      var shiftChar = this.value[this.value.length - 1];
+      this.value = this.value.slice(0, -1);
+      return shiftChar;
+    }
   }]);
   return ContinuousTailDetails;
 }();
@@ -548,6 +561,11 @@ var Masked = function () {
     get: function get() {
       return true;
     }
+  }, {
+    key: "isFilled",
+    get: function get() {
+      return this.isComplete;
+    }
   }, {
     key: "nearestInputPos",
     value: function nearestInputPos(cursorPos, direction) {
@@ -589,18 +607,30 @@ var Masked = function () {
       var flags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
       var checkTail = arguments.length > 2 ? arguments[2] : undefined;
       var consistentState = this.state;
-      var details = this._appendCharRaw(this.doPrepare(ch, flags), flags);
+      var details;
+      var _normalizePrepare = normalizePrepare(this.doPrepare(ch, flags));
+      var _normalizePrepare2 = _slicedToArray(_normalizePrepare, 2);
+      ch = _normalizePrepare2[0];
+      details = _normalizePrepare2[1];
+      details = details.aggregate(this._appendCharRaw(ch, flags));
       if (details.inserted) {
         var consistentTail;
         var appended = this.doValidate(flags) !== false;
         if (appended && checkTail != null) {
           var beforeTailState = this.state;
-          if (this.overwrite) {
+          if (this.overwrite === true) {
             consistentTail = checkTail.state;
-            checkTail.shiftBefore(this.value.length);
+            checkTail.unshift(this.value.length);
           }
           var tailDetails = this.appendTail(checkTail);
           appended = tailDetails.rawInserted === checkTail.toString();
+          if (!(appended && tailDetails.inserted) && this.overwrite === 'shift') {
+            this.state = beforeTailState;
+            consistentTail = checkTail.state;
+            checkTail.shift();
+            tailDetails = this.appendTail(checkTail);
+            appended = tailDetails.rawInserted === checkTail.toString();
+          }
           if (appended && tailDetails.inserted) this.state = beforeTailState;
         }
         if (!appended) {
@@ -616,6 +646,11 @@ var Masked = function () {
     value: function _appendPlaceholder() {
       return new ChangeDetails();
     }
+  }, {
+    key: "_appendEager",
+    value: function _appendEager() {
+      return new ChangeDetails();
+    }
   }, {
     key: "append",
     value: function append(str, flags, tail) {
@@ -629,6 +664,9 @@ var Masked = function () {
       if (checkTail != null) {
         details.tailShift += this.appendTail(checkTail).tailShift;
       }
+      if (this.eager && flags !== null && flags !== void 0 && flags.input && str) {
+        details.aggregate(this._appendEager());
+      }
       return details;
     }
   }, {
@@ -696,13 +734,37 @@ var Masked = function () {
     value: function splice(start, deleteCount, inserted, removeDirection) {
       var tailPos = start + deleteCount;
       var tail = this.extractTail(tailPos);
-      var startChangePos = this.nearestInputPos(start, removeDirection);
-      var changeDetails = new ChangeDetails({
+      var oldRawValue;
+      if (this.eager) {
+        removeDirection = forceDirection(removeDirection);
+        oldRawValue = this.extractInput(0, tailPos, {
+          raw: true
+        });
+      }
+      var startChangePos = this.nearestInputPos(start, deleteCount > 1 && start !== 0 && !this.eager ? DIRECTION.NONE : removeDirection);
+      var details = new ChangeDetails({
         tailShift: startChangePos - start
-      }).aggregate(this.remove(startChangePos)).aggregate(this.append(inserted, {
+      }).aggregate(this.remove(startChangePos));
+      if (this.eager && removeDirection !== DIRECTION.NONE && oldRawValue === this.rawInputValue) {
+        if (removeDirection === DIRECTION.FORCE_LEFT) {
+          var valLength;
+          while (oldRawValue === this.rawInputValue && (valLength = this.value.length)) {
+            details.aggregate(new ChangeDetails({
+              tailShift: -1
+            })).aggregate(this.remove(valLength - 1));
+          }
+        } else if (removeDirection === DIRECTION.FORCE_RIGHT) {
+          tail.unshift();
+        }
+      }
+      return details.aggregate(this.append(inserted, {
         input: true
       }, tail));
-      return changeDetails;
+    }
+  }, {
+    key: "maskEquals",
+    value: function maskEquals(mask) {
+      return this.mask === mask;
     }
   }]);
   return Masked;
@@ -727,8 +789,8 @@ function maskedClass(mask) {
   if (mask instanceof Number || typeof mask === 'number' || mask === Number) return IMask.MaskedNumber;
   if (Array.isArray(mask) || mask === Array) return IMask.MaskedDynamic;
   if (IMask.Masked && mask.prototype instanceof IMask.Masked) return mask;
-  if (mask instanceof Function) return IMask.MaskedFunction;
   if (mask instanceof IMask.Masked) return mask.constructor;
+  if (mask instanceof Function) return IMask.MaskedFunction;
   console.warn('Mask not found for mask', mask);
   return IMask.Masked;
 }
@@ -762,7 +824,7 @@ var PatternInputDefinition = function () {
   _createClass(PatternInputDefinition, [{
     key: "reset",
     value: function reset() {
-      this._isFilled = false;
+      this.isFilled = false;
       this.masked.reset();
     }
   }, {
@@ -771,7 +833,7 @@ var PatternInputDefinition = function () {
       var fromPos = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
       var toPos = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.value.length;
       if (fromPos === 0 && toPos >= 1) {
-        this._isFilled = false;
+        this.isFilled = false;
         return this.masked.remove(fromPos, toPos);
       }
       return new ChangeDetails();
@@ -779,7 +841,7 @@ var PatternInputDefinition = function () {
   }, {
     key: "value",
     get: function get() {
-      return this.masked.value || (this._isFilled && !this.isOptional ? this.placeholderChar : '');
+      return this.masked.value || (this.isFilled && !this.isOptional ? this.placeholderChar : '');
     }
   }, {
     key: "unmaskedValue",
@@ -793,11 +855,11 @@ var PatternInputDefinition = function () {
     }
   }, {
     key: "_appendChar",
-    value: function _appendChar(str) {
+    value: function _appendChar(ch) {
       var flags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-      if (this._isFilled) return new ChangeDetails();
+      if (this.isFilled) return new ChangeDetails();
       var state = this.masked.state;
-      var details = this.masked._appendChar(str, flags);
+      var details = this.masked._appendChar(ch, flags);
       if (details.inserted && this.doValidate(flags) === false) {
         details.inserted = details.rawInserted = '';
         this.masked.state = state;
@@ -806,7 +868,7 @@ var PatternInputDefinition = function () {
         details.inserted = this.placeholderChar;
       }
       details.skip = !details.inserted && !this.isOptional;
-      this._isFilled = Boolean(details.inserted);
+      this.isFilled = Boolean(details.inserted);
       return details;
     }
   }, {
@@ -819,11 +881,16 @@ var PatternInputDefinition = function () {
     key: "_appendPlaceholder",
     value: function _appendPlaceholder() {
       var details = new ChangeDetails();
-      if (this._isFilled || this.isOptional) return details;
-      this._isFilled = true;
+      if (this.isFilled || this.isOptional) return details;
+      this.isFilled = true;
       details.inserted = this.placeholderChar;
       return details;
     }
+  }, {
+    key: "_appendEager",
+    value: function _appendEager() {
+      return new ChangeDetails();
+    }
   }, {
     key: "extractTail",
     value: function extractTail() {
@@ -879,12 +946,12 @@ var PatternInputDefinition = function () {
     get: function get() {
       return {
         masked: this.masked.state,
-        _isFilled: this._isFilled
+        isFilled: this.isFilled
       };
     },
     set: function set(state) {
       this.masked.state = state.masked;
-      this._isFilled = state._isFilled;
+      this.isFilled = state.isFilled;
     }
   }]);
   return PatternInputDefinition;
@@ -895,6 +962,7 @@ var PatternFixedDefinition = function () {
     _classCallCheck(this, PatternFixedDefinition);
     Object.assign(this, opts);
     this._value = '';
+    this.isFixed = true;
   }
   _createClass(PatternFixedDefinition, [{
     key: "value",
@@ -951,19 +1019,29 @@ var PatternFixedDefinition = function () {
     get: function get() {
       return true;
     }
+  }, {
+    key: "isFilled",
+    get: function get() {
+      return Boolean(this._value);
+    }
   }, {
     key: "_appendChar",
-    value: function _appendChar(str) {
+    value: function _appendChar(ch) {
       var flags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
       var details = new ChangeDetails();
       if (this._value) return details;
-      var appended = this.char === str[0];
-      var isResolved = appended && (this.isUnmasking || flags.input || flags.raw) && !flags.tail;
+      var appended = this.char === ch;
+      var isResolved = appended && (this.isUnmasking || flags.input || flags.raw) && !this.eager && !flags.tail;
       if (isResolved) details.rawInserted = this.char;
       this._value = details.inserted = this.char;
       this._isRawInput = isResolved && (flags.raw || flags.input);
       return details;
     }
+  }, {
+    key: "_appendEager",
+    value: function _appendEager() {
+      return this._appendChar(this.char);
+    }
   }, {
     key: "_appendPlaceholder",
     value: function _appendPlaceholder() {
@@ -987,7 +1065,7 @@ var PatternFixedDefinition = function () {
   }, {
     key: "append",
     value: function append(str, flags, tail) {
-      var details = this._appendChar(str, flags);
+      var details = this._appendChar(str[0], flags);
       if (tail != null) {
         details.tailShift += this.appendTail(tail).tailShift;
       }
@@ -1031,7 +1109,8 @@ var ChunksTailDetails = function () {
       if (!String(tailChunk)) return;
       if (isString(tailChunk)) tailChunk = new ContinuousTailDetails(String(tailChunk));
       var lastChunk = this.chunks[this.chunks.length - 1];
-      var extendLast = lastChunk && (lastChunk.stop === tailChunk.stop || tailChunk.stop == null) &&
+      var extendLast = lastChunk && (
+      lastChunk.stop === tailChunk.stop || tailChunk.stop == null) &&
       tailChunk.from === lastChunk.from + lastChunk.toString().length;
       if (tailChunk instanceof ContinuousTailDetails) {
         if (extendLast) {
@@ -1067,7 +1146,8 @@ var ChunksTailDetails = function () {
         var lastBlockIter = masked._mapPosToBlock(masked.value.length);
         var stop = chunk.stop;
         var chunkBlock = void 0;
-        if (stop != null && (!lastBlockIter || lastBlockIter.index <= stop)) {
+        if (stop != null && (
+        !lastBlockIter || lastBlockIter.index <= stop)) {
           if (chunk instanceof ChunksTailDetails ||
           masked._stops.indexOf(stop) >= 0) {
             details.aggregate(masked._appendPlaceholder(stop));
@@ -1114,14 +1194,14 @@ var ChunksTailDetails = function () {
       });
     }
   }, {
-    key: "shiftBefore",
-    value: function shiftBefore(pos) {
-      if (this.from >= pos || !this.chunks.length) return '';
-      var chunkShiftPos = pos - this.from;
+    key: "unshift",
+    value: function unshift(beforePos) {
+      if (!this.chunks.length || beforePos != null && this.from >= beforePos) return '';
+      var chunkShiftPos = beforePos != null ? beforePos - this.from : beforePos;
       var ci = 0;
       while (ci < this.chunks.length) {
         var chunk = this.chunks[ci];
-        var shiftChar = chunk.shiftBefore(chunkShiftPos);
+        var shiftChar = chunk.unshift(chunkShiftPos);
         if (chunk.toString()) {
           if (!shiftChar) break;
           ++ci;
@@ -1132,10 +1212,178 @@ var ChunksTailDetails = function () {
       }
       return '';
     }
+  }, {
+    key: "shift",
+    value: function shift() {
+      if (!this.chunks.length) return '';
+      var ci = this.chunks.length - 1;
+      while (0 <= ci) {
+        var chunk = this.chunks[ci];
+        var shiftChar = chunk.shift();
+        if (chunk.toString()) {
+          if (!shiftChar) break;
+          --ci;
+        } else {
+          this.chunks.splice(ci, 1);
+        }
+        if (shiftChar) return shiftChar;
+      }
+      return '';
+    }
   }]);
   return ChunksTailDetails;
 }();
 
+var PatternCursor = function () {
+  function PatternCursor(masked, pos) {
+    _classCallCheck(this, PatternCursor);
+    this.masked = masked;
+    this._log = [];
+    var _ref = masked._mapPosToBlock(pos) || (pos < 0 ?
+    {
+      index: 0,
+      offset: 0
+    } :
+    {
+      index: this.masked._blocks.length,
+      offset: 0
+    }),
+        offset = _ref.offset,
+        index = _ref.index;
+    this.offset = offset;
+    this.index = index;
+    this.ok = false;
+  }
+  _createClass(PatternCursor, [{
+    key: "block",
+    get: function get() {
+      return this.masked._blocks[this.index];
+    }
+  }, {
+    key: "pos",
+    get: function get() {
+      return this.masked._blockStartPos(this.index) + this.offset;
+    }
+  }, {
+    key: "state",
+    get: function get() {
+      return {
+        index: this.index,
+        offset: this.offset,
+        ok: this.ok
+      };
+    },
+    set: function set(s) {
+      Object.assign(this, s);
+    }
+  }, {
+    key: "pushState",
+    value: function pushState() {
+      this._log.push(this.state);
+    }
+  }, {
+    key: "popState",
+    value: function popState() {
+      var s = this._log.pop();
+      this.state = s;
+      return s;
+    }
+  }, {
+    key: "bindBlock",
+    value: function bindBlock() {
+      if (this.block) return;
+      if (this.index < 0) {
+        this.index = 0;
+        this.offset = 0;
+      }
+      if (this.index >= this.masked._blocks.length) {
+        this.index = this.masked._blocks.length - 1;
+        this.offset = this.block.value.length;
+      }
+    }
+  }, {
+    key: "_pushLeft",
+    value: function _pushLeft(fn) {
+      this.pushState();
+      for (this.bindBlock(); 0 <= this.index; --this.index, this.offset = ((_this$block = this.block) === null || _this$block === void 0 ? void 0 : _this$block.value.length) || 0) {
+        var _this$block;
+        if (fn()) return this.ok = true;
+      }
+      return this.ok = false;
+    }
+  }, {
+    key: "_pushRight",
+    value: function _pushRight(fn) {
+      this.pushState();
+      for (this.bindBlock(); this.index < this.masked._blocks.length; ++this.index, this.offset = 0) {
+        if (fn()) return this.ok = true;
+      }
+      return this.ok = false;
+    }
+  }, {
+    key: "pushLeftBeforeFilled",
+    value: function pushLeftBeforeFilled() {
+      var _this = this;
+      return this._pushLeft(function () {
+        if (_this.block.isFixed || !_this.block.value) return;
+        _this.offset = _this.block.nearestInputPos(_this.offset, DIRECTION.FORCE_LEFT);
+        if (_this.offset !== 0) return true;
+      });
+    }
+  }, {
+    key: "pushLeftBeforeInput",
+    value: function pushLeftBeforeInput() {
+      var _this2 = this;
+      return this._pushLeft(function () {
+        if (_this2.block.isFixed) return;
+        _this2.offset = _this2.block.nearestInputPos(_this2.offset, DIRECTION.LEFT);
+        return true;
+      });
+    }
+  }, {
+    key: "pushLeftBeforeRequired",
+    value: function pushLeftBeforeRequired() {
+      var _this3 = this;
+      return this._pushLeft(function () {
+        if (_this3.block.isFixed || _this3.block.isOptional && !_this3.block.value) return;
+        _this3.offset = _this3.block.nearestInputPos(_this3.offset, DIRECTION.LEFT);
+        return true;
+      });
+    }
+  }, {
+    key: "pushRightBeforeFilled",
+    value: function pushRightBeforeFilled() {
+      var _this4 = this;
+      return this._pushRight(function () {
+        if (_this4.block.isFixed || !_this4.block.value) return;
+        _this4.offset = _this4.block.nearestInputPos(_this4.offset, DIRECTION.FORCE_RIGHT);
+        if (_this4.offset !== _this4.block.value.length) return true;
+      });
+    }
+  }, {
+    key: "pushRightBeforeInput",
+    value: function pushRightBeforeInput() {
+      var _this5 = this;
+      return this._pushRight(function () {
+        if (_this5.block.isFixed) return;
+        _this5.offset = _this5.block.nearestInputPos(_this5.offset, DIRECTION.NONE);
+        return true;
+      });
+    }
+  }, {
+    key: "pushRightBeforeRequired",
+    value: function pushRightBeforeRequired() {
+      var _this6 = this;
+      return this._pushRight(function () {
+        if (_this6.block.isFixed || _this6.block.isOptional && !_this6.block.value) return;
+        _this6.offset = _this6.block.nearestInputPos(_this6.offset, DIRECTION.NONE);
+        return true;
+      });
+    }
+  }]);
+  return PatternCursor;
+}();
+
 var MaskedRegExp = function (_Masked) {
   _inherits(MaskedRegExp, _Masked);
   var _super = _createSuper(MaskedRegExp);
@@ -1202,6 +1450,7 @@ var MaskedPattern = function (_Masked) {
               var maskedBlock = createMask(Object.assign({
                 parent: _this,
                 lazy: _this.lazy,
+                eager: _this.eager,
                 placeholderChar: _this.placeholderChar,
                 overwrite: _this.overwrite
               }, _this.blocks[bName]));
@@ -1217,7 +1466,7 @@ var MaskedPattern = function (_Masked) {
           if (_ret === "continue") continue;
         }
         var char = pattern[i];
-        var _isInput = (char in defs);
+        var isInput = (char in defs);
         if (char === MaskedPattern.STOP_CHAR) {
           this._stops.push(this._blocks.length);
           continue;
@@ -1234,16 +1483,18 @@ var MaskedPattern = function (_Masked) {
           ++i;
           char = pattern[i];
           if (!char) break;
-          _isInput = false;
+          isInput = false;
         }
-        var def = _isInput ? new PatternInputDefinition({
+        var def = isInput ? new PatternInputDefinition({
           parent: this,
           lazy: this.lazy,
+          eager: this.eager,
           placeholderChar: this.placeholderChar,
           mask: defs[char],
           isOptional: optionalBlock
         }) : new PatternFixedDefinition({
           char: char,
+          eager: this.eager,
           isUnmasking: unmaskingBlock
         });
         this._blocks.push(def);
@@ -1281,6 +1532,27 @@ var MaskedPattern = function (_Masked) {
         return b.isComplete;
       });
     }
+  }, {
+    key: "isFilled",
+    get: function get() {
+      return this._blocks.every(function (b) {
+        return b.isFilled;
+      });
+    }
+  }, {
+    key: "isFixed",
+    get: function get() {
+      return this._blocks.every(function (b) {
+        return b.isFixed;
+      });
+    }
+  }, {
+    key: "isOptional",
+    get: function get() {
+      return this._blocks.every(function (b) {
+        return b.isOptional;
+      });
+    }
   }, {
     key: "doCommit",
     value: function doCommit() {
@@ -1314,6 +1586,21 @@ var MaskedPattern = function (_Masked) {
     value: function appendTail(tail) {
       return _get(_getPrototypeOf(MaskedPattern.prototype), "appendTail", this).call(this, tail).aggregate(this._appendPlaceholder());
     }
+  }, {
+    key: "_appendEager",
+    value: function _appendEager() {
+      var _this$_mapPosToBlock;
+      var details = new ChangeDetails();
+      var startBlockIndex = (_this$_mapPosToBlock = this._mapPosToBlock(this.value.length)) === null || _this$_mapPosToBlock === void 0 ? void 0 : _this$_mapPosToBlock.index;
+      if (startBlockIndex == null) return details;
+      if (this._blocks[startBlockIndex].isFilled) ++startBlockIndex;
+      for (var bi = startBlockIndex; bi < this._blocks.length; ++bi) {
+        var d = this._blocks[bi]._appendEager();
+        if (!d.inserted) break;
+        details.aggregate(d);
+      }
+      return details;
+    }
   }, {
     key: "_appendCharRaw",
     value: function _appendCharRaw(ch) {
@@ -1322,9 +1609,12 @@ var MaskedPattern = function (_Masked) {
       var details = new ChangeDetails();
       if (!blockIter) return details;
       for (var bi = blockIter.index;; ++bi) {
+        var _flags$_beforeTailSta;
         var _block = this._blocks[bi];
         if (!_block) break;
-        var blockDetails = _block._appendChar(ch, flags);
+        var blockDetails = _block._appendChar(ch, Object.assign({}, flags, {
+          _beforeTailState: (_flags$_beforeTailSta = flags._beforeTailState) === null || _flags$_beforeTailSta === void 0 ? void 0 : _flags$_beforeTailSta._blocks[bi]
+        }));
         var skip = blockDetails.skip;
         details.aggregate(blockDetails);
         if (skip || blockDetails.rawInserted) break;
@@ -1449,136 +1739,49 @@ var MaskedPattern = function (_Masked) {
     key: "nearestInputPos",
     value: function nearestInputPos(cursorPos) {
       var direction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DIRECTION.NONE;
-      var beginBlockData = this._mapPosToBlock(cursorPos) || {
-        index: 0,
-        offset: 0
-      };
-      var beginBlockOffset = beginBlockData.offset,
-          beginBlockIndex = beginBlockData.index;
-      var beginBlock = this._blocks[beginBlockIndex];
-      if (!beginBlock) return cursorPos;
-      var beginBlockCursorPos = beginBlockOffset;
-      if (beginBlockCursorPos !== 0 && beginBlockCursorPos < beginBlock.value.length) {
-        beginBlockCursorPos = beginBlock.nearestInputPos(beginBlockOffset, forceDirection(direction));
-      }
-      var cursorAtRight = beginBlockCursorPos === beginBlock.value.length;
-      var cursorAtLeft = beginBlockCursorPos === 0;
-      if (!cursorAtLeft && !cursorAtRight) return this._blockStartPos(beginBlockIndex) + beginBlockCursorPos;
-      var searchBlockIndex = cursorAtRight ? beginBlockIndex + 1 : beginBlockIndex;
+      if (!this._blocks.length) return 0;
+      var cursor = new PatternCursor(this, cursorPos);
       if (direction === DIRECTION.NONE) {
-        if (searchBlockIndex > 0) {
-          var blockIndexAtLeft = searchBlockIndex - 1;
-          var blockAtLeft = this._blocks[blockIndexAtLeft];
-          var blockInputPos = blockAtLeft.nearestInputPos(0, DIRECTION.NONE);
-          if (!blockAtLeft.value.length || blockInputPos !== blockAtLeft.value.length) {
-            return this._blockStartPos(searchBlockIndex);
-          }
-        }
-        var firstInputAtRight = searchBlockIndex;
-        for (var bi = firstInputAtRight; bi < this._blocks.length; ++bi) {
-          var blockAtRight = this._blocks[bi];
-          var _blockInputPos = blockAtRight.nearestInputPos(0, DIRECTION.NONE);
-          if (!blockAtRight.value.length || _blockInputPos !== blockAtRight.value.length) {
-            return this._blockStartPos(bi) + _blockInputPos;
-          }
-        }
-        for (var _bi = searchBlockIndex - 1; _bi >= 0; --_bi) {
-          var _block3 = this._blocks[_bi];
-          var _blockInputPos2 = _block3.nearestInputPos(0, DIRECTION.NONE);
-          if (!_block3.value.length || _blockInputPos2 !== _block3.value.length) {
-            return this._blockStartPos(_bi) + _block3.value.length;
-          }
-        }
-        return cursorPos;
+        if (cursor.pushRightBeforeInput()) return cursor.pos;
+        cursor.popState();
+        if (cursor.pushLeftBeforeInput()) return cursor.pos;
+        return this.value.length;
       }
       if (direction === DIRECTION.LEFT || direction === DIRECTION.FORCE_LEFT) {
-        var firstFilledBlockIndexAtRight;
-        for (var _bi2 = searchBlockIndex; _bi2 < this._blocks.length; ++_bi2) {
-          if (this._blocks[_bi2].value) {
-            firstFilledBlockIndexAtRight = _bi2;
-            break;
-          }
-        }
-        if (firstFilledBlockIndexAtRight != null) {
-          var filledBlock = this._blocks[firstFilledBlockIndexAtRight];
-          var _blockInputPos3 = filledBlock.nearestInputPos(0, DIRECTION.RIGHT);
-          if (_blockInputPos3 === 0 && filledBlock.unmaskedValue.length) {
-            return this._blockStartPos(firstFilledBlockIndexAtRight) + _blockInputPos3;
-          }
-        }
-        var firstFilledInputBlockIndex = -1;
-        var firstEmptyInputBlockIndex;
-        for (var _bi3 = searchBlockIndex - 1; _bi3 >= 0; --_bi3) {
-          var _block4 = this._blocks[_bi3];
-          var _blockInputPos4 = _block4.nearestInputPos(_block4.value.length, DIRECTION.FORCE_LEFT);
-          if (!_block4.value || _blockInputPos4 !== 0) firstEmptyInputBlockIndex = _bi3;
-          if (_blockInputPos4 !== 0) {
-            if (_blockInputPos4 !== _block4.value.length) {
-              return this._blockStartPos(_bi3) + _blockInputPos4;
-            } else {
-              firstFilledInputBlockIndex = _bi3;
-              break;
-            }
-          }
-        }
         if (direction === DIRECTION.LEFT) {
-          for (var _bi4 = firstFilledInputBlockIndex + 1; _bi4 <= Math.min(searchBlockIndex, this._blocks.length - 1); ++_bi4) {
-            var _block5 = this._blocks[_bi4];
-            var _blockInputPos5 = _block5.nearestInputPos(0, DIRECTION.NONE);
-            var blockAlignedPos = this._blockStartPos(_bi4) + _blockInputPos5;
-            if (blockAlignedPos > cursorPos) break;
-            if (_blockInputPos5 !== _block5.value.length) return blockAlignedPos;
-          }
-        }
-        if (firstFilledInputBlockIndex >= 0) {
-          return this._blockStartPos(firstFilledInputBlockIndex) + this._blocks[firstFilledInputBlockIndex].value.length;
-        }
-        if (direction === DIRECTION.FORCE_LEFT || this.lazy && !this.extractInput() && !isInput(this._blocks[searchBlockIndex])) {
-          return 0;
-        }
-        if (firstEmptyInputBlockIndex != null) {
-          return this._blockStartPos(firstEmptyInputBlockIndex);
+          cursor.pushRightBeforeFilled();
+          if (cursor.ok && cursor.pos === cursorPos) return cursorPos;
+          cursor.popState();
         }
-        for (var _bi5 = searchBlockIndex; _bi5 < this._blocks.length; ++_bi5) {
-          var _block6 = this._blocks[_bi5];
-          var _blockInputPos6 = _block6.nearestInputPos(0, DIRECTION.NONE);
-          if (!_block6.value.length || _blockInputPos6 !== _block6.value.length) {
-            return this._blockStartPos(_bi5) + _blockInputPos6;
-          }
+        cursor.pushLeftBeforeInput();
+        cursor.pushLeftBeforeRequired();
+        cursor.pushLeftBeforeFilled();
+        if (direction === DIRECTION.LEFT) {
+          cursor.pushRightBeforeInput();
+          cursor.pushRightBeforeRequired();
+          if (cursor.ok && cursor.pos <= cursorPos) return cursor.pos;
+          cursor.popState();
+          if (cursor.ok && cursor.pos <= cursorPos) return cursor.pos;
+          cursor.popState();
         }
+        if (cursor.ok) return cursor.pos;
+        if (direction === DIRECTION.FORCE_LEFT) return 0;
+        cursor.popState();
+        if (cursor.ok) return cursor.pos;
+        cursor.popState();
+        if (cursor.ok) return cursor.pos;
         return 0;
       }
       if (direction === DIRECTION.RIGHT || direction === DIRECTION.FORCE_RIGHT) {
-        var firstInputBlockAlignedIndex;
-        var firstInputBlockAlignedPos;
-        for (var _bi6 = searchBlockIndex; _bi6 < this._blocks.length; ++_bi6) {
-          var _block7 = this._blocks[_bi6];
-          var _blockInputPos7 = _block7.nearestInputPos(0, DIRECTION.NONE);
-          if (_blockInputPos7 !== _block7.value.length) {
-            firstInputBlockAlignedPos = this._blockStartPos(_bi6) + _blockInputPos7;
-            firstInputBlockAlignedIndex = _bi6;
-            break;
-          }
-        }
-        if (firstInputBlockAlignedIndex != null && firstInputBlockAlignedPos != null) {
-          for (var _bi7 = firstInputBlockAlignedIndex; _bi7 < this._blocks.length; ++_bi7) {
-            var _block8 = this._blocks[_bi7];
-            var _blockInputPos8 = _block8.nearestInputPos(0, DIRECTION.FORCE_RIGHT);
-            if (_blockInputPos8 !== _block8.value.length) {
-              return this._blockStartPos(_bi7) + _blockInputPos8;
-            }
-          }
-          return direction === DIRECTION.FORCE_RIGHT ? this.value.length : firstInputBlockAlignedPos;
-        }
-        for (var _bi8 = Math.min(searchBlockIndex, this._blocks.length - 1); _bi8 >= 0; --_bi8) {
-          var _block9 = this._blocks[_bi8];
-          var _blockInputPos9 = _block9.nearestInputPos(_block9.value.length, DIRECTION.LEFT);
-          if (_blockInputPos9 !== 0) {
-            var alignedPos = this._blockStartPos(_bi8) + _blockInputPos9;
-            if (alignedPos >= cursorPos) return alignedPos;
-            break;
-          }
-        }
+        cursor.pushRightBeforeInput();
+        cursor.pushRightBeforeRequired();
+        if (cursor.pushRightBeforeFilled()) return cursor.pos;
+        if (direction === DIRECTION.FORCE_RIGHT) return this.value.length;
+        cursor.popState();
+        if (cursor.ok) return cursor.pos;
+        cursor.popState();
+        if (cursor.ok) return cursor.pos;
+        return this.nearestInputPos(cursorPos, DIRECTION.LEFT);
       }
       return cursorPos;
     }
@@ -1608,11 +1811,6 @@ MaskedPattern.STOP_CHAR = '`';
 MaskedPattern.ESCAPE_CHAR = '\\';
 MaskedPattern.InputDefinition = PatternInputDefinition;
 MaskedPattern.FixedDefinition = PatternFixedDefinition;
-function isInput(block) {
-  if (!block) return false;
-  var value = block.value;
-  return !value || block.nearestInputPos(0, DIRECTION.NONE) !== value.length;
-}
 IMask.MaskedPattern = MaskedPattern;
 
 var MaskedRange = function (_MaskedPattern) {
@@ -1633,7 +1831,8 @@ var MaskedRange = function (_MaskedPattern) {
     value: function _update(opts) {
       opts = Object.assign({
         to: this.to || 0,
-        from: this.from || 0
+        from: this.from || 0,
+        maxLength: this.maxLength || 0
       }, opts);
       var maxLength = String(opts.to).length;
       if (opts.maxLength != null) maxLength = Math.max(maxLength, opts.maxLength);
@@ -1671,23 +1870,30 @@ var MaskedRange = function (_MaskedPattern) {
     }
   }, {
     key: "doPrepare",
-    value: function doPrepare(str) {
+    value: function doPrepare(ch) {
       var flags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-      str = _get(_getPrototypeOf(MaskedRange.prototype), "doPrepare", this).call(this, str, flags).replace(/\D/g, '');
-      if (!this.autofix) return str;
+      var details;
+      var _normalizePrepare = normalizePrepare(_get(_getPrototypeOf(MaskedRange.prototype), "doPrepare", this).call(this, ch.replace(/\D/g, ''), flags));
+      var _normalizePrepare2 = _slicedToArray(_normalizePrepare, 2);
+      ch = _normalizePrepare2[0];
+      details = _normalizePrepare2[1];
+      if (!this.autofix || !ch) return ch;
       var fromStr = String(this.from).padStart(this.maxLength, '0');
       var toStr = String(this.to).padStart(this.maxLength, '0');
-      var val = this.value;
-      var prepStr = '';
-      for (var ci = 0; ci < str.length; ++ci) {
-        var nextVal = val + prepStr + str[ci];
-        var _this$boundaries = this.boundaries(nextVal),
-            _this$boundaries2 = _slicedToArray(_this$boundaries, 2),
-            minstr = _this$boundaries2[0],
-            maxstr = _this$boundaries2[1];
-        if (Number(maxstr) < this.from) prepStr += fromStr[nextVal.length - 1];else if (Number(minstr) > this.to) prepStr += toStr[nextVal.length - 1];else prepStr += str[ci];
+      var nextVal = this.value + ch;
+      if (nextVal.length > this.maxLength) return '';
+      var _this$boundaries = this.boundaries(nextVal),
+          _this$boundaries2 = _slicedToArray(_this$boundaries, 2),
+          minstr = _this$boundaries2[0],
+          maxstr = _this$boundaries2[1];
+      if (Number(maxstr) < this.from) return fromStr[nextVal.length - 1];
+      if (Number(minstr) > this.to) {
+        if (this.autofix === 'pad' && nextVal.length < this.maxLength) {
+          return ['', details.aggregate(this.append(fromStr[nextVal.length - 1] + ch, flags))];
+        }
+        return toStr[nextVal.length - 1];
       }
-      return prepStr;
+      return ch;
     }
   }, {
     key: "doValidate",
@@ -1734,10 +1940,10 @@ var MaskedDate = function (_MaskedPattern) {
           opts.blocks.d.to = opts.max.getDate();
         }
       }
-      Object.assign(opts.blocks, blocks);
+      Object.assign(opts.blocks, this.blocks, blocks);
       Object.keys(opts.blocks).forEach(function (bk) {
         var b = opts.blocks[bk];
-        if (!('autofix' in b)) b.autofix = opts.autofix;
+        if (!('autofix' in b) && 'autofix' in opts) b.autofix = opts.autofix;
       });
       _get(_getPrototypeOf(MaskedDate.prototype), "_update", this).call(this, opts);
     }
@@ -1772,12 +1978,18 @@ var MaskedDate = function (_MaskedPattern) {
     set: function set(value) {
       _set(_getPrototypeOf(MaskedDate.prototype), "typedValue", value, this, true);
     }
+  }, {
+    key: "maskEquals",
+    value: function maskEquals(mask) {
+      return mask === Date || _get(_getPrototypeOf(MaskedDate.prototype), "maskEquals", this).call(this, mask);
+    }
   }]);
   return MaskedDate;
 }(MaskedPattern);
 MaskedDate.DEFAULTS = {
   pattern: 'd{.}`m{.}`Y',
   format: function format(date) {
+    if (!date) return '';
     var day = String(date.getDate()).padStart(2, '0');
     var month = String(date.getMonth() + 1).padStart(2, '0');
     var year = date.getFullYear();
@@ -1879,7 +2091,8 @@ var HTMLMaskElement = function (_MaskElement) {
   _createClass(HTMLMaskElement, [{
     key: "rootElement",
     get: function get() {
-      return this.input.getRootNode ? this.input.getRootNode() : document;
+      var _this$input$getRootNo, _this$input$getRootNo2, _this$input;
+      return (_this$input$getRootNo = (_this$input$getRootNo2 = (_this$input = this.input).getRootNode) === null || _this$input$getRootNo2 === void 0 ? void 0 : _this$input$getRootNo2.call(_this$input)) !== null && _this$input$getRootNo !== void 0 ? _this$input$getRootNo : document;
     }
   }, {
     key: "isActive",
@@ -1963,14 +2176,24 @@ var HTMLContenteditableMaskElement = function (_HTMLMaskElement) {
     function get() {
       var root = this.rootElement;
       var selection = root.getSelection && root.getSelection();
-      return selection && selection.anchorOffset;
+      var anchorOffset = selection && selection.anchorOffset;
+      var focusOffset = selection && selection.focusOffset;
+      if (focusOffset == null || anchorOffset == null || anchorOffset < focusOffset) {
+        return anchorOffset;
+      }
+      return focusOffset;
     }
   }, {
     key: "_unsafeSelectionEnd",
     get: function get() {
       var root = this.rootElement;
       var selection = root.getSelection && root.getSelection();
-      return selection && this._unsafeSelectionStart + String(selection).length;
+      var anchorOffset = selection && selection.anchorOffset;
+      var focusOffset = selection && selection.focusOffset;
+      if (focusOffset == null || anchorOffset == null || anchorOffset > focusOffset) {
+        return anchorOffset;
+      }
+      return focusOffset;
     }
   }, {
     key: "_unsafeSelect",
@@ -2042,7 +2265,8 @@ var InputMask = function () {
   }, {
     key: "maskEquals",
     value: function maskEquals(mask) {
-      return mask == null || mask === this.masked.mask || mask === Date && this.masked instanceof MaskedDate;
+      var _this$masked;
+      return mask == null || ((_this$masked = this.masked) === null || _this$masked === void 0 ? void 0 : _this$masked.maskEquals(mask));
     }
   }, {
     key: "value",
@@ -2120,7 +2344,8 @@ var InputMask = function () {
     }
   }, {
     key: "_saveSelection",
-    value: function _saveSelection() {
+    value: function
+    _saveSelection() {
       if (this.value !== this.el.value) {
         console.warn('Element value was changed outside of mask. Syncronize mask using `mask.updateValue()` to work properly.');
       }
@@ -2193,7 +2418,7 @@ var InputMask = function () {
   }, {
     key: "alignCursor",
     value: function alignCursor() {
-      this.cursorPos = this.masked.nearestInputPos(this.cursorPos, DIRECTION.LEFT);
+      this.cursorPos = this.masked.nearestInputPos(this.masked.nearestInputPos(this.cursorPos, DIRECTION.LEFT));
     }
   }, {
     key: "alignCursorFriendly",
@@ -2233,6 +2458,7 @@ var InputMask = function () {
       var offset = this.masked.splice(details.startChangePos, details.removed.length, details.inserted, details.removeDirection).offset;
       var removeDirection = oldRawValue === this.masked.rawInputValue ? details.removeDirection : DIRECTION.NONE;
       var cursorPos = this.masked.nearestInputPos(details.startChangePos + offset, removeDirection);
+      if (removeDirection !== DIRECTION.NONE) cursorPos = this.masked.nearestInputPos(cursorPos, DIRECTION.NONE);
       this.updateControl();
       this.updateCursor(cursorPos);
       delete this._inputEvent;
@@ -2345,12 +2571,19 @@ var MaskedNumber = function (_Masked) {
     }
   }, {
     key: "doPrepare",
-    value: function doPrepare(str) {
+    value: function doPrepare(ch) {
       var _get2;
+      ch = ch.replace(this._mapToRadixRegExp, this.radix);
+      var noSepCh = this._removeThousandsSeparators(ch);
       for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
         args[_key - 1] = arguments[_key];
       }
-      return (_get2 = _get(_getPrototypeOf(MaskedNumber.prototype), "doPrepare", this)).call.apply(_get2, [this, this._removeThousandsSeparators(str.replace(this._mapToRadixRegExp, this.radix))].concat(args));
+      var _normalizePrepare = normalizePrepare((_get2 = _get(_getPrototypeOf(MaskedNumber.prototype), "doPrepare", this)).call.apply(_get2, [this, noSepCh].concat(args))),
+          _normalizePrepare2 = _slicedToArray(_normalizePrepare, 2),
+          prepCh = _normalizePrepare2[0],
+          details = _normalizePrepare2[1];
+      if (ch && !noSepCh) details.skip = true;
+      return [prepCh, details];
     }
   }, {
     key: "_separatorsCount",
@@ -2472,7 +2705,9 @@ var MaskedNumber = function (_Masked) {
       var valid = regexp.test(this._removeThousandsSeparators(this.value));
       if (valid) {
         var number = this.number;
-        valid = valid && !isNaN(number) && (this.min == null || this.min >= 0 || this.min <= this.number) && (this.max == null || this.max <= 0 || this.number <= this.max);
+        valid = valid && !isNaN(number) && (
+        this.min == null || this.min >= 0 || this.min <= this.number) && (
+        this.max == null || this.max <= 0 || this.number <= this.max);
       }
       return valid && _get(_getPrototypeOf(MaskedNumber.prototype), "doValidate", this).call(this, flags);
     }
@@ -2487,7 +2722,7 @@ var MaskedNumber = function (_Masked) {
         if (validnum !== number) this.unmaskedValue = String(validnum);
         var formatted = this.value;
         if (this.normalizeZeros) formatted = this._normalizeZeros(formatted);
-        if (this.padFractionalZeros) formatted = this._padFractionalZeros(formatted);
+        if (this.padFractionalZeros && this.scale > 0) formatted = this._padFractionalZeros(formatted);
         this._value = formatted;
       }
       _get(_getPrototypeOf(MaskedNumber.prototype), "doCommit", this).call(this);
@@ -2785,6 +3020,14 @@ var MaskedDynamic = function (_Masked) {
     set: function set(overwrite) {
       console.warn('"overwrite" option is not available in dynamic mask, use this option in siblings');
     }
+  }, {
+    key: "maskEquals",
+    value: function maskEquals(mask) {
+      return Array.isArray(mask) && this.compiledMasks.every(function (m, mi) {
+        var _mask$mi;
+        return m.maskEquals((_mask$mi = mask[mi]) === null || _mask$mi === void 0 ? void 0 : _mask$mi.mask);
+      });
+    }
   }]);
   return MaskedDynamic;
 }(Masked);