{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./app/javascript/packs/imask.js"],"names":["installedModules","__webpack_require__","moduleId","exports","module","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","_typeof","obj","iterator","constructor","_classCallCheck","instance","Constructor","TypeError","_defineProperties","target","props","length","descriptor","configurable","writable","_createClass","protoProps","staticProps","_inherits","subClass","superClass","_setPrototypeOf","_getPrototypeOf","setPrototypeOf","getPrototypeOf","__proto__","_objectWithoutProperties","source","excluded","sourceKeys","keys","indexOf","_objectWithoutPropertiesLoose","getOwnPropertySymbols","sourceSymbolKeys","propertyIsEnumerable","_possibleConstructorReturn","self","ReferenceError","_assertThisInitialized","_createSuper","Derived","hasNativeReflectConstruct","Reflect","construct","sham","Proxy","Boolean","valueOf","e","_isNativeReflectConstruct","result","Super","NewTarget","this","arguments","apply","_superPropBase","_get","receiver","base","desc","getOwnPropertyDescriptor","set","_defineProperty","_set","isStrict","Error","_slicedToArray","arr","Array","isArray","_arrayWithHoles","_i","_s","_e","_arr","_n","_d","next","done","push","err","_iterableToArrayLimit","_unsupportedIterableToArray","_nonIterableRest","minLen","_arrayLikeToArray","toString","slice","from","test","len","arr2","ChangeDetails","details","assign","inserted","rawInserted","skip","tailShift","isString","str","String","DIRECTION","forceDirection","direction","escapeRegExp","replace","normalizePrepare","prep","ActionDetails","cursorPos","oldValue","oldSelection","startChangePos","start","Math","min","substr","insertedCount","max","end","removedCount","substring","ContinuousTailDetails","undefined","stop","tail","masked","append","aggregate","_appendPlaceholder","state","beforePos","shiftChar","IMask","el","opts","InputMask","Masked","_value","_update","DEFAULTS","isInitialized","withValueRefresh","resolve","reset","input","doCommit","doParse","doFormat","extractInput","raw","isComplete","fromPos","toPos","appendTo","ch","flags","checkTail","consistentState","_normalizePrepare","doPrepare","_normalizePrepare2","_appendCharRaw","consistentTail","appended","doValidate","beforeTailState","overwrite","unshift","tailDetails","appendTail","shift","_beforeTailState","ci","_appendChar","eager","_appendEager","fn","_refreshing","rawInput","rawInputValue","ret","_isolated","prepare","validate","parent","commit","format","parse","deleteCount","removeDirection","oldRawValue","tailPos","extractTail","nearestInputPos","remove","valLength","mask","tval","typedValue","EMPTY_VALUES","includes","maskedClass","RegExp","MaskedRegExp","MaskedPattern","Date","MaskedDate","Number","MaskedNumber","MaskedDynamic","Function","MaskedFunction","console","warn","createMask","MaskedClass","v","_excluded$4","DEFAULT_INPUT_DEFINITIONS","PatternInputDefinition","blockOpts","isFilled","isOptional","placeholderChar","unmaskedValue","lazy","_this$masked","_this$masked2","_this$masked3","minPos","maxPos","boundPos","_this$masked4","_this$parent","PatternFixedDefinition","isFixed","isUnmasking","_isRawInput","isResolved","_excluded$3","ChunksTailDetails","chunks","map","join","tailChunk","lastChunk","extendLast","extend","firstTailChunk","blockIndex","chunk","lastBlockIter","_mapPosToBlock","chunkBlock","index","_stops","_blocks","remainChars","cstate","chunkShiftPos","splice","PatternCursor","pos","_log","_ref","offset","ok","_blockStartPos","pop","block","pushState","bindBlock","_this$block","_this","_pushLeft","_this2","_this3","_this4","_pushRight","_this5","_this6","_Masked","_super","search","_excluded$2","definitions","_rebuildMask","defs","_maskedBlocks","pattern","unmaskingBlock","optionalBlock","blocks","bNames","filter","bName","sort","a","b","maskedBlock","char","isInput","STOP_CHAR","ESCAPE_CHAR","def","maskedState","forEach","bi","every","reduce","_this$_mapPosToBlock","startBlockIndex","blockIter","_flags$_beforeTailSta","_flags$_beforeTailSta2","_block","blockDetails","chunkTail","_forEachBlocksInRange","bFromPos","bToPos","blockChunk","_findStopBefore","_","stopBefore","si","toBlockIndex","startBlockIter","endBlockIndex","args","bDetails","accVal","_block2","blockStartPos","fromBlockIter","toBlockIter","isSameBlock","fromBlockStartPos","fromBlockEndPos","removeDetails","cursor","pushRightBeforeInput","popState","pushLeftBeforeInput","pushRightBeforeFilled","pushLeftBeforeRequired","pushLeftBeforeFilled","pushRightBeforeRequired","maskedBlocks","indices","gi","InputDefinition","FixedDefinition","MaskedRange","_MaskedPattern","maxLength","to","fromStr","padStart","toStr","sameCharsCount","repeat","minstr","maxstr","_ref2","match","placeholder","num","padEnd","autofix","nextVal","_this$boundaries","boundaries","_this$boundaries2","_get2","firstNonZero","_matchFrom","_this$boundaries3","_this$boundaries4","_len","_key","concat","GET_DEFAULT_BLOCKS","Y","getFullYear","getMonth","getDate","bk","date","isDateExist","_str$split2","split","day","month","year","MaskElement","_unsafeSelectionStart","_unsafeSelectionEnd","selectionStart","selectionEnd","_unsafeSelect","handlers","HTMLMaskElement","_MaskElement","_handlers","_this$input$getRootNo","_this$input$getRootNo2","_this$input","getRootNode","document","rootElement","activeElement","setSelectionRange","event","_toggleEventHandler","EVENTS_MAP","handler","removeEventListener","addEventListener","selectionChange","drop","click","focus","HTMLContenteditableMaskElement","_HTMLMaskElement","root","selection","getSelection","anchorOffset","focusOffset","createRange","range","setStart","firstChild","setEnd","lastChild","removeAllRanges","addRange","textContent","_excluded$1","isContentEditable","tagName","_listeners","_unmaskedValue","_saveSelection","_onInput","_onChange","_onDrop","_onFocus","_onClick","alignCursor","alignCursorFriendly","_bindEvents","updateValue","maskEquals","updateOptions","updateControl","val","typedValueEquals","bindEvents","unbindEvents","ev","listeners","_cursorChanging","_changingCursorPos","isActive","select","_selection","newUnmaskedValue","newValue","isChanged","_fireChangeEvents","restOpts","updateMask","updateOpts","objectIncludes","arrA","arrB","dateA","dateB","getTime","regexpA","regexpB","_delayUpdateCursor","_abortUpdateCursor","setTimeout","_fireEvent","_inputEvent","clearTimeout","hIndex","removed","updateCursor","preventDefault","stopPropagation","_unbindEvents","MaskedEnum","some","_updateRegExps","allowNegative","scale","radix","_numberRegExpInput","_numberRegExp","_mapToRadixRegExp","mapToRadix","_thousandsSeparatorRegExp","thousandsSeparator","parts","noSepCh","_removeThousandsSeparators","prepCh","extendOnSeparators","count","_separatorsCount","_this$_adjustRangeWit","_adjustRangeWithSeparators","_this$_adjustRangeWit2","prevBeforeTailValue","prevBeforeTailSeparatorsCount","_separatorsCountFromSlice","appendDetails","_insertThousandsSeparators","beforeTailValue","beforeTailSeparatorsCount","searchFrom","separatorPos","separatorAroundFromPos","_findSeparatorAround","separatorAroundToPos","_this$_adjustRangeWit3","_this$_adjustRangeWit4","valueBeforePos","valueAfterPos","separatorAtLeftPos","separatorAtLeftEndPos","separatorAtRightPos","valid","number","isNaN","validnum","formatted","normalizeZeros","_normalizeZeros","padFractionalZeros","_padFractionalZeros","sign","zeros","signed","_arrayWithoutHoles","iter","_iterableToArray","_nonIterableSpread","_excluded","currentMask","compiledMasks","_applyDispatch","currentMaskFlags","prevValueBeforeTail","inputValue","insertValue","_rawInputValue","tailValue","prevMask","prevMaskState","doDispatch","currentMaskRef","dispatch","currentDetails","_normalizePrepare3","_normalizePrepare4","_this$currentMask","_this$currentMask2","_this$currentMask3","_this$currentMask4","_this$currentMask5","mi","_this$currentMask6","_this$currentMask7","_this$currentMask8","_get3","_len2","_key2","_mask$mi","_this$currentMask9","inputs","weight","i1","i2","PIPE_TYPE","MASKED","UNMASKED","TYPED","createPipe","runIsolated","pipe","pipeArgs","globalThis","factory"],"mappings":"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","file":"js/imask-5909377304c7542224f6.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/cl/inversionistas/packs/\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 13);\n","(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :\n  typeof define === 'function' && define.amd ? define(['exports'], factory) :\n  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.IMask = {}));\n})(this, (function (exports) { 'use strict';\n\n  function _typeof(obj) {\n    \"@babel/helpers - typeof\";\n\n    return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n      return typeof obj;\n    } : function (obj) {\n      return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    }, _typeof(obj);\n  }\n\n  function _classCallCheck(instance, Constructor) {\n    if (!(instance instanceof Constructor)) {\n      throw new TypeError(\"Cannot call a class as a function\");\n    }\n  }\n\n  function _defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      Object.defineProperty(target, descriptor.key, descriptor);\n    }\n  }\n\n  function _createClass(Constructor, protoProps, staticProps) {\n    if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) _defineProperties(Constructor, staticProps);\n    Object.defineProperty(Constructor, \"prototype\", {\n      writable: false\n    });\n    return Constructor;\n  }\n\n  function _defineProperty(obj, key, value) {\n    if (key in obj) {\n      Object.defineProperty(obj, key, {\n        value: value,\n        enumerable: true,\n        configurable: true,\n        writable: true\n      });\n    } else {\n      obj[key] = value;\n    }\n\n    return obj;\n  }\n\n  function _inherits(subClass, superClass) {\n    if (typeof superClass !== \"function\" && superClass !== null) {\n      throw new TypeError(\"Super expression must either be null or a function\");\n    }\n\n    subClass.prototype = Object.create(superClass && superClass.prototype, {\n      constructor: {\n        value: subClass,\n        writable: true,\n        configurable: true\n      }\n    });\n    Object.defineProperty(subClass, \"prototype\", {\n      writable: false\n    });\n    if (superClass) _setPrototypeOf(subClass, superClass);\n  }\n\n  function _getPrototypeOf(o) {\n    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {\n      return o.__proto__ || Object.getPrototypeOf(o);\n    };\n    return _getPrototypeOf(o);\n  }\n\n  function _setPrototypeOf(o, p) {\n    _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {\n      o.__proto__ = p;\n      return o;\n    };\n    return _setPrototypeOf(o, p);\n  }\n\n  function _isNativeReflectConstruct() {\n    if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n    if (Reflect.construct.sham) return false;\n    if (typeof Proxy === \"function\") return true;\n\n    try {\n      Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }\n\n  function _objectWithoutPropertiesLoose(source, excluded) {\n    if (source == null) return {};\n    var target = {};\n    var sourceKeys = Object.keys(source);\n    var key, i;\n\n    for (i = 0; i < sourceKeys.length; i++) {\n      key = sourceKeys[i];\n      if (excluded.indexOf(key) >= 0) continue;\n      target[key] = source[key];\n    }\n\n    return target;\n  }\n\n  function _objectWithoutProperties(source, excluded) {\n    if (source == null) return {};\n\n    var target = _objectWithoutPropertiesLoose(source, excluded);\n\n    var key, i;\n\n    if (Object.getOwnPropertySymbols) {\n      var sourceSymbolKeys = Object.getOwnPropertySymbols(source);\n\n      for (i = 0; i < sourceSymbolKeys.length; i++) {\n        key = sourceSymbolKeys[i];\n        if (excluded.indexOf(key) >= 0) continue;\n        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;\n        target[key] = source[key];\n      }\n    }\n\n    return target;\n  }\n\n  function _assertThisInitialized(self) {\n    if (self === void 0) {\n      throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n    }\n\n    return self;\n  }\n\n  function _possibleConstructorReturn(self, call) {\n    if (call && (typeof call === \"object\" || typeof call === \"function\")) {\n      return call;\n    } else if (call !== void 0) {\n      throw new TypeError(\"Derived constructors may only return object or undefined\");\n    }\n\n    return _assertThisInitialized(self);\n  }\n\n  function _createSuper(Derived) {\n    var hasNativeReflectConstruct = _isNativeReflectConstruct();\n\n    return function _createSuperInternal() {\n      var Super = _getPrototypeOf(Derived),\n          result;\n\n      if (hasNativeReflectConstruct) {\n        var NewTarget = _getPrototypeOf(this).constructor;\n\n        result = Reflect.construct(Super, arguments, NewTarget);\n      } else {\n        result = Super.apply(this, arguments);\n      }\n\n      return _possibleConstructorReturn(this, result);\n    };\n  }\n\n  function _superPropBase(object, property) {\n    while (!Object.prototype.hasOwnProperty.call(object, property)) {\n      object = _getPrototypeOf(object);\n      if (object === null) break;\n    }\n\n    return object;\n  }\n\n  function _get() {\n    if (typeof Reflect !== \"undefined\" && Reflect.get) {\n      _get = Reflect.get.bind();\n    } else {\n      _get = function _get(target, property, receiver) {\n        var base = _superPropBase(target, property);\n\n        if (!base) return;\n        var desc = Object.getOwnPropertyDescriptor(base, property);\n\n        if (desc.get) {\n          return desc.get.call(arguments.length < 3 ? target : receiver);\n        }\n\n        return desc.value;\n      };\n    }\n\n    return _get.apply(this, arguments);\n  }\n\n  function set(target, property, value, receiver) {\n    if (typeof Reflect !== \"undefined\" && Reflect.set) {\n      set = Reflect.set;\n    } else {\n      set = function set(target, property, value, receiver) {\n        var base = _superPropBase(target, property);\n\n        var desc;\n\n        if (base) {\n          desc = Object.getOwnPropertyDescriptor(base, property);\n\n          if (desc.set) {\n            desc.set.call(receiver, value);\n            return true;\n          } else if (!desc.writable) {\n            return false;\n          }\n        }\n\n        desc = Object.getOwnPropertyDescriptor(receiver, property);\n\n        if (desc) {\n          if (!desc.writable) {\n            return false;\n          }\n\n          desc.value = value;\n          Object.defineProperty(receiver, property, desc);\n        } else {\n          _defineProperty(receiver, property, value);\n        }\n\n        return true;\n      };\n    }\n\n    return set(target, property, value, receiver);\n  }\n\n  function _set(target, property, value, receiver, isStrict) {\n    var s = set(target, property, value, receiver || target);\n\n    if (!s && isStrict) {\n      throw new Error('failed to set property');\n    }\n\n    return value;\n  }\n\n  function _slicedToArray(arr, i) {\n    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();\n  }\n\n  function _toConsumableArray(arr) {\n    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();\n  }\n\n  function _arrayWithoutHoles(arr) {\n    if (Array.isArray(arr)) return _arrayLikeToArray(arr);\n  }\n\n  function _arrayWithHoles(arr) {\n    if (Array.isArray(arr)) return arr;\n  }\n\n  function _iterableToArray(iter) {\n    if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter);\n  }\n\n  function _iterableToArrayLimit(arr, i) {\n    var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"];\n\n    if (_i == null) return;\n    var _arr = [];\n    var _n = true;\n    var _d = false;\n\n    var _s, _e;\n\n    try {\n      for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {\n        _arr.push(_s.value);\n\n        if (i && _arr.length === i) break;\n      }\n    } catch (err) {\n      _d = true;\n      _e = err;\n    } finally {\n      try {\n        if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n      } finally {\n        if (_d) throw _e;\n      }\n    }\n\n    return _arr;\n  }\n\n  function _unsupportedIterableToArray(o, minLen) {\n    if (!o) return;\n    if (typeof o === \"string\") return _arrayLikeToArray(o, minLen);\n    var n = Object.prototype.toString.call(o).slice(8, -1);\n    if (n === \"Object\" && o.constructor) n = o.constructor.name;\n    if (n === \"Map\" || n === \"Set\") return Array.from(o);\n    if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);\n  }\n\n  function _arrayLikeToArray(arr, len) {\n    if (len == null || len > arr.length) len = arr.length;\n\n    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];\n\n    return arr2;\n  }\n\n  function _nonIterableSpread() {\n    throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n  }\n\n  function _nonIterableRest() {\n    throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n  }\n\n  /**\n    Provides details of changing model value\n    @param {Object} [details]\n    @param {string} [details.inserted] - Inserted symbols\n    @param {boolean} [details.skip] - Can skip chars\n    @param {number} [details.removeCount] - Removed symbols count\n    @param {number} [details.tailShift] - Additional offset if any changes occurred before tail\n  */\n  var ChangeDetails = /*#__PURE__*/function () {\n    /** Inserted symbols */\n\n    /** Can skip chars */\n\n    /** Additional offset if any changes occurred before tail */\n\n    /** Raw inserted is used by dynamic mask */\n    function ChangeDetails(details) {\n      _classCallCheck(this, ChangeDetails);\n\n      Object.assign(this, {\n        inserted: '',\n        rawInserted: '',\n        skip: false,\n        tailShift: 0\n      }, details);\n    }\n    /**\n      Aggregate changes\n      @returns {ChangeDetails} `this`\n    */\n\n\n    _createClass(ChangeDetails, [{\n      key: \"aggregate\",\n      value: function aggregate(details) {\n        this.rawInserted += details.rawInserted;\n        this.skip = this.skip || details.skip;\n        this.inserted += details.inserted;\n        this.tailShift += details.tailShift;\n        return this;\n      }\n      /** Total offset considering all changes */\n\n    }, {\n      key: \"offset\",\n      get: function get() {\n        return this.tailShift + this.inserted.length;\n      }\n    }]);\n\n    return ChangeDetails;\n  }();\n\n  /** Checks if value is string */\n\n  function isString(str) {\n    return typeof str === 'string' || str instanceof String;\n  }\n  /**\n    Direction\n    @prop {string} NONE\n    @prop {string} LEFT\n    @prop {string} FORCE_LEFT\n    @prop {string} RIGHT\n    @prop {string} FORCE_RIGHT\n  */\n\n  var DIRECTION = {\n    NONE: 'NONE',\n    LEFT: 'LEFT',\n    FORCE_LEFT: 'FORCE_LEFT',\n    RIGHT: 'RIGHT',\n    FORCE_RIGHT: 'FORCE_RIGHT'\n  };\n  /** */\n\n  function forceDirection(direction) {\n    switch (direction) {\n      case DIRECTION.LEFT:\n        return DIRECTION.FORCE_LEFT;\n\n      case DIRECTION.RIGHT:\n        return DIRECTION.FORCE_RIGHT;\n\n      default:\n        return direction;\n    }\n  }\n  /** Escapes regular expression control chars */\n\n  function escapeRegExp(str) {\n    return str.replace(/([.*+?^=!:${}()|[\\]\\/\\\\])/g, '\\\\$1');\n  }\n  function normalizePrepare(prep) {\n    return Array.isArray(prep) ? prep : [prep, new ChangeDetails()];\n  } // cloned from https://github.com/epoberezkin/fast-deep-equal with small changes\n\n  function objectIncludes(b, a) {\n    if (a === b) return true;\n    var arrA = Array.isArray(a),\n        arrB = Array.isArray(b),\n        i;\n\n    if (arrA && arrB) {\n      if (a.length != b.length) return false;\n\n      for (i = 0; i < a.length; i++) {\n        if (!objectIncludes(a[i], b[i])) return false;\n      }\n\n      return true;\n    }\n\n    if (arrA != arrB) return false;\n\n    if (a && b && _typeof(a) === 'object' && _typeof(b) === 'object') {\n      var dateA = a instanceof Date,\n          dateB = b instanceof Date;\n      if (dateA && dateB) return a.getTime() == b.getTime();\n      if (dateA != dateB) return false;\n      var regexpA = a instanceof RegExp,\n          regexpB = b instanceof RegExp;\n      if (regexpA && regexpB) return a.toString() == b.toString();\n      if (regexpA != regexpB) return false;\n      var keys = Object.keys(a); // if (keys.length !== Object.keys(b).length) return false;\n\n      for (i = 0; i < keys.length; i++) {\n        // $FlowFixMe ... ???\n        if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;\n      }\n\n      for (i = 0; i < keys.length; i++) {\n        if (!objectIncludes(b[keys[i]], a[keys[i]])) return false;\n      }\n\n      return true;\n    } else if (a && b && typeof a === 'function' && typeof b === 'function') {\n      return a.toString() === b.toString();\n    }\n\n    return false;\n  }\n  /** Selection range */\n\n  /** Provides details of changing input */\n\n  var ActionDetails = /*#__PURE__*/function () {\n    /** Current input value */\n\n    /** Current cursor position */\n\n    /** Old input value */\n\n    /** Old selection */\n    function ActionDetails(value, cursorPos, oldValue, oldSelection) {\n      _classCallCheck(this, ActionDetails);\n\n      this.value = value;\n      this.cursorPos = cursorPos;\n      this.oldValue = oldValue;\n      this.oldSelection = oldSelection; // double check if left part was changed (autofilling, other non-standard input triggers)\n\n      while (this.value.slice(0, this.startChangePos) !== this.oldValue.slice(0, this.startChangePos)) {\n        --this.oldSelection.start;\n      }\n    }\n    /**\n      Start changing position\n      @readonly\n    */\n\n\n    _createClass(ActionDetails, [{\n      key: \"startChangePos\",\n      get: function get() {\n        return Math.min(this.cursorPos, this.oldSelection.start);\n      }\n      /**\n        Inserted symbols count\n        @readonly\n      */\n\n    }, {\n      key: \"insertedCount\",\n      get: function get() {\n        return this.cursorPos - this.startChangePos;\n      }\n      /**\n        Inserted symbols\n        @readonly\n      */\n\n    }, {\n      key: \"inserted\",\n      get: function get() {\n        return this.value.substr(this.startChangePos, this.insertedCount);\n      }\n      /**\n        Removed symbols count\n        @readonly\n      */\n\n    }, {\n      key: \"removedCount\",\n      get: function get() {\n        // Math.max for opposite operation\n        return Math.max(this.oldSelection.end - this.startChangePos || // for Delete\n        this.oldValue.length - this.value.length, 0);\n      }\n      /**\n        Removed symbols\n        @readonly\n      */\n\n    }, {\n      key: \"removed\",\n      get: function get() {\n        return this.oldValue.substr(this.startChangePos, this.removedCount);\n      }\n      /**\n        Unchanged head symbols\n        @readonly\n      */\n\n    }, {\n      key: \"head\",\n      get: function get() {\n        return this.value.substring(0, this.startChangePos);\n      }\n      /**\n        Unchanged tail symbols\n        @readonly\n      */\n\n    }, {\n      key: \"tail\",\n      get: function get() {\n        return this.value.substring(this.startChangePos + this.insertedCount);\n      }\n      /**\n        Remove direction\n        @readonly\n      */\n\n    }, {\n      key: \"removeDirection\",\n      get: function get() {\n        if (!this.removedCount || this.insertedCount) return DIRECTION.NONE; // align right if delete at right\n\n        return (this.oldSelection.end === this.cursorPos || this.oldSelection.start === this.cursorPos) && // if not range removed (event with backspace)\n        this.oldSelection.end === this.oldSelection.start ? DIRECTION.RIGHT : DIRECTION.LEFT;\n      }\n    }]);\n\n    return ActionDetails;\n  }();\n\n  /** Provides details of continuous extracted tail */\n  var ContinuousTailDetails = /*#__PURE__*/function () {\n    /** Tail value as string */\n\n    /** Tail start position */\n\n    /** Start position */\n    function ContinuousTailDetails() {\n      var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';\n      var from = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n      var stop = arguments.length > 2 ? arguments[2] : undefined;\n\n      _classCallCheck(this, ContinuousTailDetails);\n\n      this.value = value;\n      this.from = from;\n      this.stop = stop;\n    }\n\n    _createClass(ContinuousTailDetails, [{\n      key: \"toString\",\n      value: function toString() {\n        return this.value;\n      }\n    }, {\n      key: \"extend\",\n      value: function extend(tail) {\n        this.value += String(tail);\n      }\n    }, {\n      key: \"appendTo\",\n      value: function appendTo(masked) {\n        return masked.append(this.toString(), {\n          tail: true\n        }).aggregate(masked._appendPlaceholder());\n      }\n    }, {\n      key: \"state\",\n      get: function get() {\n        return {\n          value: this.value,\n          from: this.from,\n          stop: this.stop\n        };\n      },\n      set: function set(state) {\n        Object.assign(this, state);\n      }\n    }, {\n      key: \"unshift\",\n      value: function unshift(beforePos) {\n        if (!this.value.length || beforePos != null && this.from >= beforePos) return '';\n        var shiftChar = this.value[0];\n        this.value = this.value.slice(1);\n        return shiftChar;\n      }\n    }, {\n      key: \"shift\",\n      value: function shift() {\n        if (!this.value.length) return '';\n        var shiftChar = this.value[this.value.length - 1];\n        this.value = this.value.slice(0, -1);\n        return shiftChar;\n      }\n    }]);\n\n    return ContinuousTailDetails;\n  }();\n\n  /**\n   * Applies mask on element.\n   * @constructor\n   * @param {HTMLInputElement|HTMLTextAreaElement|MaskElement} el - Element to apply mask\n   * @param {Object} opts - Custom mask options\n   * @return {InputMask}\n   */\n  function IMask(el) {\n    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    // currently available only for input-like elements\n    return new IMask.InputMask(el, opts);\n  }\n\n  /** Supported mask type */\n\n  /** Provides common masking stuff */\n  var Masked = /*#__PURE__*/function () {\n    // $Shape<MaskedOptions>; TODO after fix https://github.com/facebook/flow/issues/4773\n\n    /** @type {Mask} */\n\n    /** */\n    // $FlowFixMe no ideas\n\n    /** Transforms value before mask processing */\n\n    /** Validates if value is acceptable */\n\n    /** Does additional processing in the end of editing */\n\n    /** Format typed value to string */\n\n    /** Parse strgin to get typed value */\n\n    /** Enable characters overwriting */\n\n    /** */\n\n    /** */\n    function Masked(opts) {\n      _classCallCheck(this, Masked);\n\n      this._value = '';\n\n      this._update(Object.assign({}, Masked.DEFAULTS, opts));\n\n      this.isInitialized = true;\n    }\n    /** Sets and applies new options */\n\n\n    _createClass(Masked, [{\n      key: \"updateOptions\",\n      value: function updateOptions(opts) {\n        if (!Object.keys(opts).length) return; // $FlowFixMe\n\n        this.withValueRefresh(this._update.bind(this, opts));\n      }\n      /**\n        Sets new options\n        @protected\n      */\n\n    }, {\n      key: \"_update\",\n      value: function _update(opts) {\n        Object.assign(this, opts);\n      }\n      /** Mask state */\n\n    }, {\n      key: \"state\",\n      get: function get() {\n        return {\n          _value: this.value\n        };\n      },\n      set: function set(state) {\n        this._value = state._value;\n      }\n      /** Resets value */\n\n    }, {\n      key: \"reset\",\n      value: function reset() {\n        this._value = '';\n      }\n      /** */\n\n    }, {\n      key: \"value\",\n      get: function get() {\n        return this._value;\n      },\n      set: function set(value) {\n        this.resolve(value);\n      }\n      /** Resolve new value */\n\n    }, {\n      key: \"resolve\",\n      value: function resolve(value) {\n        this.reset();\n        this.append(value, {\n          input: true\n        }, '');\n        this.doCommit();\n        return this.value;\n      }\n      /** */\n\n    }, {\n      key: \"unmaskedValue\",\n      get: function get() {\n        return this.value;\n      },\n      set: function set(value) {\n        this.reset();\n        this.append(value, {}, '');\n        this.doCommit();\n      }\n      /** */\n\n    }, {\n      key: \"typedValue\",\n      get: function get() {\n        return this.doParse(this.value);\n      },\n      set: function set(value) {\n        this.value = this.doFormat(value);\n      }\n      /** Value that includes raw user input */\n\n    }, {\n      key: \"rawInputValue\",\n      get: function get() {\n        return this.extractInput(0, this.value.length, {\n          raw: true\n        });\n      },\n      set: function set(value) {\n        this.reset();\n        this.append(value, {\n          raw: true\n        }, '');\n        this.doCommit();\n      }\n      /** */\n\n    }, {\n      key: \"isComplete\",\n      get: function get() {\n        return true;\n      }\n      /** */\n\n    }, {\n      key: \"isFilled\",\n      get: function get() {\n        return this.isComplete;\n      }\n      /** Finds nearest input position in direction */\n\n    }, {\n      key: \"nearestInputPos\",\n      value: function nearestInputPos(cursorPos, direction) {\n        return cursorPos;\n      }\n      /** Extracts value in range considering flags */\n\n    }, {\n      key: \"extractInput\",\n      value: function extractInput() {\n        var fromPos = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n        var toPos = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.value.length;\n        return this.value.slice(fromPos, toPos);\n      }\n      /** Extracts tail in range */\n\n    }, {\n      key: \"extractTail\",\n      value: function extractTail() {\n        var fromPos = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n        var toPos = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.value.length;\n        return new ContinuousTailDetails(this.extractInput(fromPos, toPos), fromPos);\n      }\n      /** Appends tail */\n      // $FlowFixMe no ideas\n\n    }, {\n      key: \"appendTail\",\n      value: function appendTail(tail) {\n        if (isString(tail)) tail = new ContinuousTailDetails(String(tail));\n        return tail.appendTo(this);\n      }\n      /** Appends char */\n\n    }, {\n      key: \"_appendCharRaw\",\n      value: function _appendCharRaw(ch) {\n        if (!ch) return new ChangeDetails();\n        this._value += ch;\n        return new ChangeDetails({\n          inserted: ch,\n          rawInserted: ch\n        });\n      }\n      /** Appends char */\n\n    }, {\n      key: \"_appendChar\",\n      value: function _appendChar(ch) {\n        var flags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n        var checkTail = arguments.length > 2 ? arguments[2] : undefined;\n        var consistentState = this.state;\n        var details;\n\n        var _normalizePrepare = normalizePrepare(this.doPrepare(ch, flags));\n\n        var _normalizePrepare2 = _slicedToArray(_normalizePrepare, 2);\n\n        ch = _normalizePrepare2[0];\n        details = _normalizePrepare2[1];\n        details = details.aggregate(this._appendCharRaw(ch, flags));\n\n        if (details.inserted) {\n          var consistentTail;\n          var appended = this.doValidate(flags) !== false;\n\n          if (appended && checkTail != null) {\n            // validation ok, check tail\n            var beforeTailState = this.state;\n\n            if (this.overwrite === true) {\n              consistentTail = checkTail.state;\n              checkTail.unshift(this.value.length);\n            }\n\n            var tailDetails = this.appendTail(checkTail);\n            appended = tailDetails.rawInserted === checkTail.toString(); // not ok, try shift\n\n            if (!(appended && tailDetails.inserted) && this.overwrite === 'shift') {\n              this.state = beforeTailState;\n              consistentTail = checkTail.state;\n              checkTail.shift();\n              tailDetails = this.appendTail(checkTail);\n              appended = tailDetails.rawInserted === checkTail.toString();\n            } // if ok, rollback state after tail\n\n\n            if (appended && tailDetails.inserted) this.state = beforeTailState;\n          } // revert all if something went wrong\n\n\n          if (!appended) {\n            details = new ChangeDetails();\n            this.state = consistentState;\n            if (checkTail && consistentTail) checkTail.state = consistentTail;\n          }\n        }\n\n        return details;\n      }\n      /** Appends optional placeholder at end */\n\n    }, {\n      key: \"_appendPlaceholder\",\n      value: function _appendPlaceholder() {\n        return new ChangeDetails();\n      }\n      /** Appends optional eager placeholder at end */\n\n    }, {\n      key: \"_appendEager\",\n      value: function _appendEager() {\n        return new ChangeDetails();\n      }\n      /** Appends symbols considering flags */\n      // $FlowFixMe no ideas\n\n    }, {\n      key: \"append\",\n      value: function append(str, flags, tail) {\n        if (!isString(str)) throw new Error('value should be string');\n        var details = new ChangeDetails();\n        var checkTail = isString(tail) ? new ContinuousTailDetails(String(tail)) : tail;\n        if (flags !== null && flags !== void 0 && flags.tail) flags._beforeTailState = this.state;\n\n        for (var ci = 0; ci < str.length; ++ci) {\n          details.aggregate(this._appendChar(str[ci], flags, checkTail));\n        } // append tail but aggregate only tailShift\n\n\n        if (checkTail != null) {\n          details.tailShift += this.appendTail(checkTail).tailShift; // TODO it's a good idea to clear state after appending ends\n          // but it causes bugs when one append calls another (when dynamic dispatch set rawInputValue)\n          // this._resetBeforeTailState();\n        }\n\n        if (this.eager && flags !== null && flags !== void 0 && flags.input && str) {\n          details.aggregate(this._appendEager());\n        }\n\n        return details;\n      }\n      /** */\n\n    }, {\n      key: \"remove\",\n      value: function remove() {\n        var fromPos = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n        var toPos = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.value.length;\n        this._value = this.value.slice(0, fromPos) + this.value.slice(toPos);\n        return new ChangeDetails();\n      }\n      /** Calls function and reapplies current value */\n\n    }, {\n      key: \"withValueRefresh\",\n      value: function withValueRefresh(fn) {\n        if (this._refreshing || !this.isInitialized) return fn();\n        this._refreshing = true;\n        var rawInput = this.rawInputValue;\n        var value = this.value;\n        var ret = fn();\n        this.rawInputValue = rawInput; // append lost trailing chars at end\n\n        if (this.value && this.value !== value && value.indexOf(this.value) === 0) {\n          this.append(value.slice(this.value.length), {}, '');\n        }\n\n        delete this._refreshing;\n        return ret;\n      }\n      /** */\n\n    }, {\n      key: \"runIsolated\",\n      value: function runIsolated(fn) {\n        if (this._isolated || !this.isInitialized) return fn(this);\n        this._isolated = true;\n        var state = this.state;\n        var ret = fn(this);\n        this.state = state;\n        delete this._isolated;\n        return ret;\n      }\n      /**\n        Prepares string before mask processing\n        @protected\n      */\n\n    }, {\n      key: \"doPrepare\",\n      value: function doPrepare(str) {\n        var flags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n        return this.prepare ? this.prepare(str, this, flags) : str;\n      }\n      /**\n        Validates if value is acceptable\n        @protected\n      */\n\n    }, {\n      key: \"doValidate\",\n      value: function doValidate(flags) {\n        return (!this.validate || this.validate(this.value, this, flags)) && (!this.parent || this.parent.doValidate(flags));\n      }\n      /**\n        Does additional processing in the end of editing\n        @protected\n      */\n\n    }, {\n      key: \"doCommit\",\n      value: function doCommit() {\n        if (this.commit) this.commit(this.value, this);\n      }\n      /** */\n\n    }, {\n      key: \"doFormat\",\n      value: function doFormat(value) {\n        return this.format ? this.format(value, this) : value;\n      }\n      /** */\n\n    }, {\n      key: \"doParse\",\n      value: function doParse(str) {\n        return this.parse ? this.parse(str, this) : str;\n      }\n      /** */\n\n    }, {\n      key: \"splice\",\n      value: function splice(start, deleteCount, inserted, removeDirection) {\n        var flags = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {\n          input: true\n        };\n        var tailPos = start + deleteCount;\n        var tail = this.extractTail(tailPos);\n        var oldRawValue;\n\n        if (this.eager) {\n          removeDirection = forceDirection(removeDirection);\n          oldRawValue = this.extractInput(0, tailPos, {\n            raw: true\n          });\n        }\n\n        var startChangePos = this.nearestInputPos(start, deleteCount > 1 && start !== 0 && !this.eager ? DIRECTION.NONE : removeDirection);\n        var details = new ChangeDetails({\n          tailShift: startChangePos - start // adjust tailShift if start was aligned\n\n        }).aggregate(this.remove(startChangePos));\n\n        if (this.eager && removeDirection !== DIRECTION.NONE && oldRawValue === this.rawInputValue) {\n          if (removeDirection === DIRECTION.FORCE_LEFT) {\n            var valLength;\n\n            while (oldRawValue === this.rawInputValue && (valLength = this.value.length)) {\n              details.aggregate(new ChangeDetails({\n                tailShift: -1\n              })).aggregate(this.remove(valLength - 1));\n            }\n          } else if (removeDirection === DIRECTION.FORCE_RIGHT) {\n            tail.unshift();\n          }\n        }\n\n        return details.aggregate(this.append(inserted, flags, tail));\n      }\n    }, {\n      key: \"maskEquals\",\n      value: function maskEquals(mask) {\n        return this.mask === mask;\n      }\n    }, {\n      key: \"typedValueEquals\",\n      value: function typedValueEquals(value) {\n        var tval = this.typedValue;\n        return value === tval || Masked.EMPTY_VALUES.includes(value) && Masked.EMPTY_VALUES.includes(tval) || this.doFormat(value) === this.doFormat(this.typedValue);\n      }\n    }]);\n\n    return Masked;\n  }();\n  Masked.DEFAULTS = {\n    format: function format(v) {\n      return v;\n    },\n    parse: function parse(v) {\n      return v;\n    }\n  };\n  Masked.EMPTY_VALUES = [undefined, null, ''];\n  IMask.Masked = Masked;\n\n  /** Get Masked class by mask type */\n\n  function maskedClass(mask) {\n    if (mask == null) {\n      throw new Error('mask property should be defined');\n    } // $FlowFixMe\n\n\n    if (mask instanceof RegExp) return IMask.MaskedRegExp; // $FlowFixMe\n\n    if (isString(mask)) return IMask.MaskedPattern; // $FlowFixMe\n\n    if (mask instanceof Date || mask === Date) return IMask.MaskedDate; // $FlowFixMe\n\n    if (mask instanceof Number || typeof mask === 'number' || mask === Number) return IMask.MaskedNumber; // $FlowFixMe\n\n    if (Array.isArray(mask) || mask === Array) return IMask.MaskedDynamic; // $FlowFixMe\n\n    if (IMask.Masked && mask.prototype instanceof IMask.Masked) return mask; // $FlowFixMe\n\n    if (mask instanceof IMask.Masked) return mask.constructor; // $FlowFixMe\n\n    if (mask instanceof Function) return IMask.MaskedFunction;\n    console.warn('Mask not found for mask', mask); // eslint-disable-line no-console\n    // $FlowFixMe\n\n    return IMask.Masked;\n  }\n  /** Creates new {@link Masked} depending on mask type */\n\n  function createMask(opts) {\n    // $FlowFixMe\n    if (IMask.Masked && opts instanceof IMask.Masked) return opts;\n    opts = Object.assign({}, opts);\n    var mask = opts.mask; // $FlowFixMe\n\n    if (IMask.Masked && mask instanceof IMask.Masked) return mask;\n    var MaskedClass = maskedClass(mask);\n    if (!MaskedClass) throw new Error('Masked class is not found for provided mask, appropriate module needs to be import manually before creating mask.');\n    return new MaskedClass(opts);\n  }\n  IMask.createMask = createMask;\n\n  var _excluded$4 = [\"mask\"];\n  var DEFAULT_INPUT_DEFINITIONS = {\n    '0': /\\d/,\n    'a': /[\\u0041-\\u005A\\u0061-\\u007A\\u00AA\\u00B5\\u00BA\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u0527\\u0531-\\u0556\\u0559\\u0561-\\u0587\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0620-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0800-\\u0815\\u081A\\u0824\\u0828\\u0840-\\u0858\\u08A0\\u08A2-\\u08AC\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971-\\u0977\\u0979-\\u097F\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C33\\u0C35-\\u0C39\\u0C3D\\u0C58\\u0C59\\u0C60\\u0C61\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0CF1\\u0CF2\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D\\u0D4E\\u0D60\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC-\\u0EDF\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8C\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F4\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1877\\u1880-\\u18A8\\u18AA\\u18B0-\\u18F5\\u1900-\\u191C\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19C1-\\u19C7\\u1A00-\\u1A16\\u1A20-\\u1A54\\u1AA7\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1BBA-\\u1BE5\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1CE9-\\u1CEC\\u1CEE-\\u1CF1\\u1CF5\\u1CF6\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u209C\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2119-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u212D\\u212F-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2183\\u2184\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2CE4\\u2CEB-\\u2CEE\\u2CF2\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u2E2F\\u3005\\u3006\\u3031-\\u3035\\u303B\\u303C\\u3041-\\u3096\\u309D-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312D\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FCC\\uA000-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA66E\\uA67F-\\uA697\\uA6A0-\\uA6E5\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA78E\\uA790-\\uA793\\uA7A0-\\uA7AA\\uA7F8-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA8F2-\\uA8F7\\uA8FB\\uA90A-\\uA925\\uA930-\\uA946\\uA960-\\uA97C\\uA984-\\uA9B2\\uA9CF\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAA60-\\uAA76\\uAA7A\\uAA80-\\uAAAF\\uAAB1\\uAAB5\\uAAB6\\uAAB9-\\uAABD\\uAAC0\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEA\\uAAF2-\\uAAF4\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uABC0-\\uABE2\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC]/,\n    // http://stackoverflow.com/a/22075070\n    '*': /./\n  };\n  /** */\n\n  var PatternInputDefinition = /*#__PURE__*/function () {\n    /** */\n\n    /** */\n\n    /** */\n\n    /** */\n\n    /** */\n\n    /** */\n\n    /** */\n    function PatternInputDefinition(opts) {\n      _classCallCheck(this, PatternInputDefinition);\n\n      var mask = opts.mask,\n          blockOpts = _objectWithoutProperties(opts, _excluded$4);\n\n      this.masked = createMask({\n        mask: mask\n      });\n      Object.assign(this, blockOpts);\n    }\n\n    _createClass(PatternInputDefinition, [{\n      key: \"reset\",\n      value: function reset() {\n        this.isFilled = false;\n        this.masked.reset();\n      }\n    }, {\n      key: \"remove\",\n      value: function remove() {\n        var fromPos = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n        var toPos = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.value.length;\n\n        if (fromPos === 0 && toPos >= 1) {\n          this.isFilled = false;\n          return this.masked.remove(fromPos, toPos);\n        }\n\n        return new ChangeDetails();\n      }\n    }, {\n      key: \"value\",\n      get: function get() {\n        return this.masked.value || (this.isFilled && !this.isOptional ? this.placeholderChar : '');\n      }\n    }, {\n      key: \"unmaskedValue\",\n      get: function get() {\n        return this.masked.unmaskedValue;\n      }\n    }, {\n      key: \"isComplete\",\n      get: function get() {\n        return Boolean(this.masked.value) || this.isOptional;\n      }\n    }, {\n      key: \"_appendChar\",\n      value: function _appendChar(ch) {\n        var flags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n        if (this.isFilled) return new ChangeDetails();\n        var state = this.masked.state; // simulate input\n\n        var details = this.masked._appendChar(ch, flags);\n\n        if (details.inserted && this.doValidate(flags) === false) {\n          details.inserted = details.rawInserted = '';\n          this.masked.state = state;\n        }\n\n        if (!details.inserted && !this.isOptional && !this.lazy && !flags.input) {\n          details.inserted = this.placeholderChar;\n        }\n\n        details.skip = !details.inserted && !this.isOptional;\n        this.isFilled = Boolean(details.inserted);\n        return details;\n      }\n    }, {\n      key: \"append\",\n      value: function append() {\n        var _this$masked;\n\n        // TODO probably should be done via _appendChar\n        return (_this$masked = this.masked).append.apply(_this$masked, arguments);\n      }\n    }, {\n      key: \"_appendPlaceholder\",\n      value: function _appendPlaceholder() {\n        var details = new ChangeDetails();\n        if (this.isFilled || this.isOptional) return details;\n        this.isFilled = true;\n        details.inserted = this.placeholderChar;\n        return details;\n      }\n    }, {\n      key: \"_appendEager\",\n      value: function _appendEager() {\n        return new ChangeDetails();\n      }\n    }, {\n      key: \"extractTail\",\n      value: function extractTail() {\n        var _this$masked2;\n\n        return (_this$masked2 = this.masked).extractTail.apply(_this$masked2, arguments);\n      }\n    }, {\n      key: \"appendTail\",\n      value: function appendTail() {\n        var _this$masked3;\n\n        return (_this$masked3 = this.masked).appendTail.apply(_this$masked3, arguments);\n      }\n    }, {\n      key: \"extractInput\",\n      value: function extractInput() {\n        var fromPos = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n        var toPos = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.value.length;\n        var flags = arguments.length > 2 ? arguments[2] : undefined;\n        return this.masked.extractInput(fromPos, toPos, flags);\n      }\n    }, {\n      key: \"nearestInputPos\",\n      value: function nearestInputPos(cursorPos) {\n        var direction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DIRECTION.NONE;\n        var minPos = 0;\n        var maxPos = this.value.length;\n        var boundPos = Math.min(Math.max(cursorPos, minPos), maxPos);\n\n        switch (direction) {\n          case DIRECTION.LEFT:\n          case DIRECTION.FORCE_LEFT:\n            return this.isComplete ? boundPos : minPos;\n\n          case DIRECTION.RIGHT:\n          case DIRECTION.FORCE_RIGHT:\n            return this.isComplete ? boundPos : maxPos;\n\n          case DIRECTION.NONE:\n          default:\n            return boundPos;\n        }\n      }\n    }, {\n      key: \"doValidate\",\n      value: function doValidate() {\n        var _this$masked4, _this$parent;\n\n        return (_this$masked4 = this.masked).doValidate.apply(_this$masked4, arguments) && (!this.parent || (_this$parent = this.parent).doValidate.apply(_this$parent, arguments));\n      }\n    }, {\n      key: \"doCommit\",\n      value: function doCommit() {\n        this.masked.doCommit();\n      }\n    }, {\n      key: \"state\",\n      get: function get() {\n        return {\n          masked: this.masked.state,\n          isFilled: this.isFilled\n        };\n      },\n      set: function set(state) {\n        this.masked.state = state.masked;\n        this.isFilled = state.isFilled;\n      }\n    }]);\n\n    return PatternInputDefinition;\n  }();\n\n  var PatternFixedDefinition = /*#__PURE__*/function () {\n    /** */\n\n    /** */\n\n    /** */\n\n    /** */\n\n    /** */\n\n    /** */\n    function PatternFixedDefinition(opts) {\n      _classCallCheck(this, PatternFixedDefinition);\n\n      Object.assign(this, opts);\n      this._value = '';\n      this.isFixed = true;\n    }\n\n    _createClass(PatternFixedDefinition, [{\n      key: \"value\",\n      get: function get() {\n        return this._value;\n      }\n    }, {\n      key: \"unmaskedValue\",\n      get: function get() {\n        return this.isUnmasking ? this.value : '';\n      }\n    }, {\n      key: \"reset\",\n      value: function reset() {\n        this._isRawInput = false;\n        this._value = '';\n      }\n    }, {\n      key: \"remove\",\n      value: function remove() {\n        var fromPos = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n        var toPos = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this._value.length;\n        this._value = this._value.slice(0, fromPos) + this._value.slice(toPos);\n        if (!this._value) this._isRawInput = false;\n        return new ChangeDetails();\n      }\n    }, {\n      key: \"nearestInputPos\",\n      value: function nearestInputPos(cursorPos) {\n        var direction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DIRECTION.NONE;\n        var minPos = 0;\n        var maxPos = this._value.length;\n\n        switch (direction) {\n          case DIRECTION.LEFT:\n          case DIRECTION.FORCE_LEFT:\n            return minPos;\n\n          case DIRECTION.NONE:\n          case DIRECTION.RIGHT:\n          case DIRECTION.FORCE_RIGHT:\n          default:\n            return maxPos;\n        }\n      }\n    }, {\n      key: \"extractInput\",\n      value: function extractInput() {\n        var fromPos = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n        var toPos = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this._value.length;\n        var flags = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n        return flags.raw && this._isRawInput && this._value.slice(fromPos, toPos) || '';\n      }\n    }, {\n      key: \"isComplete\",\n      get: function get() {\n        return true;\n      }\n    }, {\n      key: \"isFilled\",\n      get: function get() {\n        return Boolean(this._value);\n      }\n    }, {\n      key: \"_appendChar\",\n      value: function _appendChar(ch) {\n        var flags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n        var details = new ChangeDetails();\n        if (this._value) return details;\n        var appended = this.char === ch;\n        var isResolved = appended && (this.isUnmasking || flags.input || flags.raw) && (!flags.raw || !this.eager) && !flags.tail;\n        if (isResolved) details.rawInserted = this.char;\n        this._value = details.inserted = this.char;\n        this._isRawInput = isResolved && (flags.raw || flags.input);\n        return details;\n      }\n    }, {\n      key: \"_appendEager\",\n      value: function _appendEager() {\n        return this._appendChar(this.char, {\n          tail: true\n        });\n      }\n    }, {\n      key: \"_appendPlaceholder\",\n      value: function _appendPlaceholder() {\n        var details = new ChangeDetails();\n        if (this._value) return details;\n        this._value = details.inserted = this.char;\n        return details;\n      }\n    }, {\n      key: \"extractTail\",\n      value: function extractTail() {\n        arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.value.length;\n        return new ContinuousTailDetails('');\n      } // $FlowFixMe no ideas\n\n    }, {\n      key: \"appendTail\",\n      value: function appendTail(tail) {\n        if (isString(tail)) tail = new ContinuousTailDetails(String(tail));\n        return tail.appendTo(this);\n      }\n    }, {\n      key: \"append\",\n      value: function append(str, flags, tail) {\n        var details = this._appendChar(str[0], flags);\n\n        if (tail != null) {\n          details.tailShift += this.appendTail(tail).tailShift;\n        }\n\n        return details;\n      }\n    }, {\n      key: \"doCommit\",\n      value: function doCommit() {}\n    }, {\n      key: \"state\",\n      get: function get() {\n        return {\n          _value: this._value,\n          _isRawInput: this._isRawInput\n        };\n      },\n      set: function set(state) {\n        Object.assign(this, state);\n      }\n    }]);\n\n    return PatternFixedDefinition;\n  }();\n\n  var _excluded$3 = [\"chunks\"];\n\n  var ChunksTailDetails = /*#__PURE__*/function () {\n    /** */\n    function ChunksTailDetails() {\n      var chunks = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];\n      var from = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n\n      _classCallCheck(this, ChunksTailDetails);\n\n      this.chunks = chunks;\n      this.from = from;\n    }\n\n    _createClass(ChunksTailDetails, [{\n      key: \"toString\",\n      value: function toString() {\n        return this.chunks.map(String).join('');\n      } // $FlowFixMe no ideas\n\n    }, {\n      key: \"extend\",\n      value: function extend(tailChunk) {\n        if (!String(tailChunk)) return;\n        if (isString(tailChunk)) tailChunk = new ContinuousTailDetails(String(tailChunk));\n        var lastChunk = this.chunks[this.chunks.length - 1];\n        var extendLast = lastChunk && ( // if stops are same or tail has no stop\n        lastChunk.stop === tailChunk.stop || tailChunk.stop == null) && // if tail chunk goes just after last chunk\n        tailChunk.from === lastChunk.from + lastChunk.toString().length;\n\n        if (tailChunk instanceof ContinuousTailDetails) {\n          // check the ability to extend previous chunk\n          if (extendLast) {\n            // extend previous chunk\n            lastChunk.extend(tailChunk.toString());\n          } else {\n            // append new chunk\n            this.chunks.push(tailChunk);\n          }\n        } else if (tailChunk instanceof ChunksTailDetails) {\n          if (tailChunk.stop == null) {\n            // unwrap floating chunks to parent, keeping `from` pos\n            var firstTailChunk;\n\n            while (tailChunk.chunks.length && tailChunk.chunks[0].stop == null) {\n              firstTailChunk = tailChunk.chunks.shift();\n              firstTailChunk.from += tailChunk.from;\n              this.extend(firstTailChunk);\n            }\n          } // if tail chunk still has value\n\n\n          if (tailChunk.toString()) {\n            // if chunks contains stops, then popup stop to container\n            tailChunk.stop = tailChunk.blockIndex;\n            this.chunks.push(tailChunk);\n          }\n        }\n      }\n    }, {\n      key: \"appendTo\",\n      value: function appendTo(masked) {\n        // $FlowFixMe\n        if (!(masked instanceof IMask.MaskedPattern)) {\n          var tail = new ContinuousTailDetails(this.toString());\n          return tail.appendTo(masked);\n        }\n\n        var details = new ChangeDetails();\n\n        for (var ci = 0; ci < this.chunks.length && !details.skip; ++ci) {\n          var chunk = this.chunks[ci];\n\n          var lastBlockIter = masked._mapPosToBlock(masked.value.length);\n\n          var stop = chunk.stop;\n          var chunkBlock = void 0;\n\n          if (stop != null && ( // if block not found or stop is behind lastBlock\n          !lastBlockIter || lastBlockIter.index <= stop)) {\n            if (chunk instanceof ChunksTailDetails || // for continuous block also check if stop is exist\n            masked._stops.indexOf(stop) >= 0) {\n              details.aggregate(masked._appendPlaceholder(stop));\n            }\n\n            chunkBlock = chunk instanceof ChunksTailDetails && masked._blocks[stop];\n          }\n\n          if (chunkBlock) {\n            var tailDetails = chunkBlock.appendTail(chunk);\n            tailDetails.skip = false; // always ignore skip, it will be set on last\n\n            details.aggregate(tailDetails);\n            masked._value += tailDetails.inserted; // get not inserted chars\n\n            var remainChars = chunk.toString().slice(tailDetails.rawInserted.length);\n            if (remainChars) details.aggregate(masked.append(remainChars, {\n              tail: true\n            }));\n          } else {\n            details.aggregate(masked.append(chunk.toString(), {\n              tail: true\n            }));\n          }\n        }\n        return details;\n      }\n    }, {\n      key: \"state\",\n      get: function get() {\n        return {\n          chunks: this.chunks.map(function (c) {\n            return c.state;\n          }),\n          from: this.from,\n          stop: this.stop,\n          blockIndex: this.blockIndex\n        };\n      },\n      set: function set(state) {\n        var chunks = state.chunks,\n            props = _objectWithoutProperties(state, _excluded$3);\n\n        Object.assign(this, props);\n        this.chunks = chunks.map(function (cstate) {\n          var chunk = \"chunks\" in cstate ? new ChunksTailDetails() : new ContinuousTailDetails(); // $FlowFixMe already checked above\n\n          chunk.state = cstate;\n          return chunk;\n        });\n      }\n    }, {\n      key: \"unshift\",\n      value: function unshift(beforePos) {\n        if (!this.chunks.length || beforePos != null && this.from >= beforePos) return '';\n        var chunkShiftPos = beforePos != null ? beforePos - this.from : beforePos;\n        var ci = 0;\n\n        while (ci < this.chunks.length) {\n          var chunk = this.chunks[ci];\n          var shiftChar = chunk.unshift(chunkShiftPos);\n\n          if (chunk.toString()) {\n            // chunk still contains value\n            // but not shifted - means no more available chars to shift\n            if (!shiftChar) break;\n            ++ci;\n          } else {\n            // clean if chunk has no value\n            this.chunks.splice(ci, 1);\n          }\n\n          if (shiftChar) return shiftChar;\n        }\n\n        return '';\n      }\n    }, {\n      key: \"shift\",\n      value: function shift() {\n        if (!this.chunks.length) return '';\n        var ci = this.chunks.length - 1;\n\n        while (0 <= ci) {\n          var chunk = this.chunks[ci];\n          var shiftChar = chunk.shift();\n\n          if (chunk.toString()) {\n            // chunk still contains value\n            // but not shifted - means no more available chars to shift\n            if (!shiftChar) break;\n            --ci;\n          } else {\n            // clean if chunk has no value\n            this.chunks.splice(ci, 1);\n          }\n\n          if (shiftChar) return shiftChar;\n        }\n\n        return '';\n      }\n    }]);\n\n    return ChunksTailDetails;\n  }();\n\n  var PatternCursor = /*#__PURE__*/function () {\n    function PatternCursor(masked, pos) {\n      _classCallCheck(this, PatternCursor);\n\n      this.masked = masked;\n      this._log = [];\n\n      var _ref = masked._mapPosToBlock(pos) || (pos < 0 ? // first\n      {\n        index: 0,\n        offset: 0\n      } : // last\n      {\n        index: this.masked._blocks.length,\n        offset: 0\n      }),\n          offset = _ref.offset,\n          index = _ref.index;\n\n      this.offset = offset;\n      this.index = index;\n      this.ok = false;\n    }\n\n    _createClass(PatternCursor, [{\n      key: \"block\",\n      get: function get() {\n        return this.masked._blocks[this.index];\n      }\n    }, {\n      key: \"pos\",\n      get: function get() {\n        return this.masked._blockStartPos(this.index) + this.offset;\n      }\n    }, {\n      key: \"state\",\n      get: function get() {\n        return {\n          index: this.index,\n          offset: this.offset,\n          ok: this.ok\n        };\n      },\n      set: function set(s) {\n        Object.assign(this, s);\n      }\n    }, {\n      key: \"pushState\",\n      value: function pushState() {\n        this._log.push(this.state);\n      }\n    }, {\n      key: \"popState\",\n      value: function popState() {\n        var s = this._log.pop();\n\n        this.state = s;\n        return s;\n      }\n    }, {\n      key: \"bindBlock\",\n      value: function bindBlock() {\n        if (this.block) return;\n\n        if (this.index < 0) {\n          this.index = 0;\n          this.offset = 0;\n        }\n\n        if (this.index >= this.masked._blocks.length) {\n          this.index = this.masked._blocks.length - 1;\n          this.offset = this.block.value.length;\n        }\n      }\n    }, {\n      key: \"_pushLeft\",\n      value: function _pushLeft(fn) {\n        this.pushState();\n\n        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) {\n          var _this$block;\n\n          if (fn()) return this.ok = true;\n        }\n\n        return this.ok = false;\n      }\n    }, {\n      key: \"_pushRight\",\n      value: function _pushRight(fn) {\n        this.pushState();\n\n        for (this.bindBlock(); this.index < this.masked._blocks.length; ++this.index, this.offset = 0) {\n          if (fn()) return this.ok = true;\n        }\n\n        return this.ok = false;\n      }\n    }, {\n      key: \"pushLeftBeforeFilled\",\n      value: function pushLeftBeforeFilled() {\n        var _this = this;\n\n        return this._pushLeft(function () {\n          if (_this.block.isFixed || !_this.block.value) return;\n          _this.offset = _this.block.nearestInputPos(_this.offset, DIRECTION.FORCE_LEFT);\n          if (_this.offset !== 0) return true;\n        });\n      }\n    }, {\n      key: \"pushLeftBeforeInput\",\n      value: function pushLeftBeforeInput() {\n        var _this2 = this;\n\n        // cases:\n        // filled input: 00|\n        // optional empty input: 00[]|\n        // nested block: XX<[]>|\n        return this._pushLeft(function () {\n          if (_this2.block.isFixed) return;\n          _this2.offset = _this2.block.nearestInputPos(_this2.offset, DIRECTION.LEFT);\n          return true;\n        });\n      }\n    }, {\n      key: \"pushLeftBeforeRequired\",\n      value: function pushLeftBeforeRequired() {\n        var _this3 = this;\n\n        return this._pushLeft(function () {\n          if (_this3.block.isFixed || _this3.block.isOptional && !_this3.block.value) return;\n          _this3.offset = _this3.block.nearestInputPos(_this3.offset, DIRECTION.LEFT);\n          return true;\n        });\n      }\n    }, {\n      key: \"pushRightBeforeFilled\",\n      value: function pushRightBeforeFilled() {\n        var _this4 = this;\n\n        return this._pushRight(function () {\n          if (_this4.block.isFixed || !_this4.block.value) return;\n          _this4.offset = _this4.block.nearestInputPos(_this4.offset, DIRECTION.FORCE_RIGHT);\n          if (_this4.offset !== _this4.block.value.length) return true;\n        });\n      }\n    }, {\n      key: \"pushRightBeforeInput\",\n      value: function pushRightBeforeInput() {\n        var _this5 = this;\n\n        return this._pushRight(function () {\n          if (_this5.block.isFixed) return; // const o = this.offset;\n\n          _this5.offset = _this5.block.nearestInputPos(_this5.offset, DIRECTION.NONE); // HACK cases like (STILL DOES NOT WORK FOR NESTED)\n          // aa|X\n          // aa<X|[]>X_    - this will not work\n          // if (o && o === this.offset && this.block instanceof PatternInputDefinition) continue;\n\n          return true;\n        });\n      }\n    }, {\n      key: \"pushRightBeforeRequired\",\n      value: function pushRightBeforeRequired() {\n        var _this6 = this;\n\n        return this._pushRight(function () {\n          if (_this6.block.isFixed || _this6.block.isOptional && !_this6.block.value) return; // TODO check |[*]XX_\n\n          _this6.offset = _this6.block.nearestInputPos(_this6.offset, DIRECTION.NONE);\n          return true;\n        });\n      }\n    }]);\n\n    return PatternCursor;\n  }();\n\n  /** Masking by RegExp */\n\n  var MaskedRegExp = /*#__PURE__*/function (_Masked) {\n    _inherits(MaskedRegExp, _Masked);\n\n    var _super = _createSuper(MaskedRegExp);\n\n    function MaskedRegExp() {\n      _classCallCheck(this, MaskedRegExp);\n\n      return _super.apply(this, arguments);\n    }\n\n    _createClass(MaskedRegExp, [{\n      key: \"_update\",\n      value:\n      /**\n        @override\n        @param {Object} opts\n      */\n      function _update(opts) {\n        if (opts.mask) opts.validate = function (value) {\n          return value.search(opts.mask) >= 0;\n        };\n\n        _get(_getPrototypeOf(MaskedRegExp.prototype), \"_update\", this).call(this, opts);\n      }\n    }]);\n\n    return MaskedRegExp;\n  }(Masked);\n  IMask.MaskedRegExp = MaskedRegExp;\n\n  var _excluded$2 = [\"_blocks\"];\n\n  /**\n    Pattern mask\n    @param {Object} opts\n    @param {Object} opts.blocks\n    @param {Object} opts.definitions\n    @param {string} opts.placeholderChar\n    @param {boolean} opts.lazy\n  */\n  var MaskedPattern = /*#__PURE__*/function (_Masked) {\n    _inherits(MaskedPattern, _Masked);\n\n    var _super = _createSuper(MaskedPattern);\n\n    /** */\n\n    /** */\n\n    /** Single char for empty input */\n\n    /** Show placeholder only when needed */\n    function MaskedPattern() {\n      var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n      _classCallCheck(this, MaskedPattern);\n\n      // TODO type $Shape<MaskedPatternOptions>={} does not work\n      opts.definitions = Object.assign({}, DEFAULT_INPUT_DEFINITIONS, opts.definitions);\n      return _super.call(this, Object.assign({}, MaskedPattern.DEFAULTS, opts));\n    }\n    /**\n      @override\n      @param {Object} opts\n    */\n\n\n    _createClass(MaskedPattern, [{\n      key: \"_update\",\n      value: function _update() {\n        var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n        opts.definitions = Object.assign({}, this.definitions, opts.definitions);\n\n        _get(_getPrototypeOf(MaskedPattern.prototype), \"_update\", this).call(this, opts);\n\n        this._rebuildMask();\n      }\n      /** */\n\n    }, {\n      key: \"_rebuildMask\",\n      value: function _rebuildMask() {\n        var _this = this;\n\n        var defs = this.definitions;\n        this._blocks = [];\n        this._stops = [];\n        this._maskedBlocks = {};\n        var pattern = this.mask;\n        if (!pattern || !defs) return;\n        var unmaskingBlock = false;\n        var optionalBlock = false;\n\n        for (var i = 0; i < pattern.length; ++i) {\n          if (this.blocks) {\n            var _ret = function () {\n              var p = pattern.slice(i);\n              var bNames = Object.keys(_this.blocks).filter(function (bName) {\n                return p.indexOf(bName) === 0;\n              }); // order by key length\n\n              bNames.sort(function (a, b) {\n                return b.length - a.length;\n              }); // use block name with max length\n\n              var bName = bNames[0];\n\n              if (bName) {\n                // $FlowFixMe no ideas\n                var maskedBlock = createMask(Object.assign({\n                  parent: _this,\n                  lazy: _this.lazy,\n                  eager: _this.eager,\n                  placeholderChar: _this.placeholderChar,\n                  overwrite: _this.overwrite\n                }, _this.blocks[bName]));\n\n                if (maskedBlock) {\n                  _this._blocks.push(maskedBlock); // store block index\n\n\n                  if (!_this._maskedBlocks[bName]) _this._maskedBlocks[bName] = [];\n\n                  _this._maskedBlocks[bName].push(_this._blocks.length - 1);\n                }\n\n                i += bName.length - 1;\n                return \"continue\";\n              }\n            }();\n\n            if (_ret === \"continue\") continue;\n          }\n\n          var char = pattern[i];\n          var isInput = (char in defs);\n\n          if (char === MaskedPattern.STOP_CHAR) {\n            this._stops.push(this._blocks.length);\n\n            continue;\n          }\n\n          if (char === '{' || char === '}') {\n            unmaskingBlock = !unmaskingBlock;\n            continue;\n          }\n\n          if (char === '[' || char === ']') {\n            optionalBlock = !optionalBlock;\n            continue;\n          }\n\n          if (char === MaskedPattern.ESCAPE_CHAR) {\n            ++i;\n            char = pattern[i];\n            if (!char) break;\n            isInput = false;\n          }\n\n          var def = isInput ? new PatternInputDefinition({\n            parent: this,\n            lazy: this.lazy,\n            eager: this.eager,\n            placeholderChar: this.placeholderChar,\n            mask: defs[char],\n            isOptional: optionalBlock\n          }) : new PatternFixedDefinition({\n            char: char,\n            eager: this.eager,\n            isUnmasking: unmaskingBlock\n          });\n\n          this._blocks.push(def);\n        }\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"state\",\n      get: function get() {\n        return Object.assign({}, _get(_getPrototypeOf(MaskedPattern.prototype), \"state\", this), {\n          _blocks: this._blocks.map(function (b) {\n            return b.state;\n          })\n        });\n      },\n      set: function set(state) {\n        var _blocks = state._blocks,\n            maskedState = _objectWithoutProperties(state, _excluded$2);\n\n        this._blocks.forEach(function (b, bi) {\n          return b.state = _blocks[bi];\n        });\n\n        _set(_getPrototypeOf(MaskedPattern.prototype), \"state\", maskedState, this, true);\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"reset\",\n      value: function reset() {\n        _get(_getPrototypeOf(MaskedPattern.prototype), \"reset\", this).call(this);\n\n        this._blocks.forEach(function (b) {\n          return b.reset();\n        });\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"isComplete\",\n      get: function get() {\n        return this._blocks.every(function (b) {\n          return b.isComplete;\n        });\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"isFilled\",\n      get: function get() {\n        return this._blocks.every(function (b) {\n          return b.isFilled;\n        });\n      }\n    }, {\n      key: \"isFixed\",\n      get: function get() {\n        return this._blocks.every(function (b) {\n          return b.isFixed;\n        });\n      }\n    }, {\n      key: \"isOptional\",\n      get: function get() {\n        return this._blocks.every(function (b) {\n          return b.isOptional;\n        });\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"doCommit\",\n      value: function doCommit() {\n        this._blocks.forEach(function (b) {\n          return b.doCommit();\n        });\n\n        _get(_getPrototypeOf(MaskedPattern.prototype), \"doCommit\", this).call(this);\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"unmaskedValue\",\n      get: function get() {\n        return this._blocks.reduce(function (str, b) {\n          return str += b.unmaskedValue;\n        }, '');\n      },\n      set: function set(unmaskedValue) {\n        _set(_getPrototypeOf(MaskedPattern.prototype), \"unmaskedValue\", unmaskedValue, this, true);\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"value\",\n      get: function get() {\n        // TODO return _value when not in change?\n        return this._blocks.reduce(function (str, b) {\n          return str += b.value;\n        }, '');\n      },\n      set: function set(value) {\n        _set(_getPrototypeOf(MaskedPattern.prototype), \"value\", value, this, true);\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"appendTail\",\n      value: function appendTail(tail) {\n        return _get(_getPrototypeOf(MaskedPattern.prototype), \"appendTail\", this).call(this, tail).aggregate(this._appendPlaceholder());\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"_appendEager\",\n      value: function _appendEager() {\n        var _this$_mapPosToBlock;\n\n        var details = new ChangeDetails();\n        var startBlockIndex = (_this$_mapPosToBlock = this._mapPosToBlock(this.value.length)) === null || _this$_mapPosToBlock === void 0 ? void 0 : _this$_mapPosToBlock.index;\n        if (startBlockIndex == null) return details; // TODO test if it works for nested pattern masks\n\n        if (this._blocks[startBlockIndex].isFilled) ++startBlockIndex;\n\n        for (var bi = startBlockIndex; bi < this._blocks.length; ++bi) {\n          var d = this._blocks[bi]._appendEager();\n\n          if (!d.inserted) break;\n          details.aggregate(d);\n        }\n\n        return details;\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"_appendCharRaw\",\n      value: function _appendCharRaw(ch) {\n        var flags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n        var blockIter = this._mapPosToBlock(this.value.length);\n\n        var details = new ChangeDetails();\n        if (!blockIter) return details;\n\n        for (var bi = blockIter.index;; ++bi) {\n          var _flags$_beforeTailSta, _flags$_beforeTailSta2;\n\n          var _block = this._blocks[bi];\n          if (!_block) break;\n\n          var blockDetails = _block._appendChar(ch, Object.assign({}, flags, {\n            _beforeTailState: (_flags$_beforeTailSta = flags._beforeTailState) === null || _flags$_beforeTailSta === void 0 ? void 0 : (_flags$_beforeTailSta2 = _flags$_beforeTailSta._blocks) === null || _flags$_beforeTailSta2 === void 0 ? void 0 : _flags$_beforeTailSta2[bi]\n          }));\n\n          var skip = blockDetails.skip;\n          details.aggregate(blockDetails);\n          if (skip || blockDetails.rawInserted) break; // go next char\n        }\n\n        return details;\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"extractTail\",\n      value: function extractTail() {\n        var _this2 = this;\n\n        var fromPos = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n        var toPos = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.value.length;\n        var chunkTail = new ChunksTailDetails();\n        if (fromPos === toPos) return chunkTail;\n\n        this._forEachBlocksInRange(fromPos, toPos, function (b, bi, bFromPos, bToPos) {\n          var blockChunk = b.extractTail(bFromPos, bToPos);\n          blockChunk.stop = _this2._findStopBefore(bi);\n          blockChunk.from = _this2._blockStartPos(bi);\n          if (blockChunk instanceof ChunksTailDetails) blockChunk.blockIndex = bi;\n          chunkTail.extend(blockChunk);\n        });\n\n        return chunkTail;\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"extractInput\",\n      value: function extractInput() {\n        var fromPos = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n        var toPos = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.value.length;\n        var flags = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n        if (fromPos === toPos) return '';\n        var input = '';\n\n        this._forEachBlocksInRange(fromPos, toPos, function (b, _, fromPos, toPos) {\n          input += b.extractInput(fromPos, toPos, flags);\n        });\n\n        return input;\n      }\n    }, {\n      key: \"_findStopBefore\",\n      value: function _findStopBefore(blockIndex) {\n        var stopBefore;\n\n        for (var si = 0; si < this._stops.length; ++si) {\n          var stop = this._stops[si];\n          if (stop <= blockIndex) stopBefore = stop;else break;\n        }\n\n        return stopBefore;\n      }\n      /** Appends placeholder depending on laziness */\n\n    }, {\n      key: \"_appendPlaceholder\",\n      value: function _appendPlaceholder(toBlockIndex) {\n        var _this3 = this;\n\n        var details = new ChangeDetails();\n        if (this.lazy && toBlockIndex == null) return details;\n\n        var startBlockIter = this._mapPosToBlock(this.value.length);\n\n        if (!startBlockIter) return details;\n        var startBlockIndex = startBlockIter.index;\n        var endBlockIndex = toBlockIndex != null ? toBlockIndex : this._blocks.length;\n\n        this._blocks.slice(startBlockIndex, endBlockIndex).forEach(function (b) {\n          if (!b.lazy || toBlockIndex != null) {\n            // $FlowFixMe `_blocks` may not be present\n            var args = b._blocks != null ? [b._blocks.length] : [];\n\n            var bDetails = b._appendPlaceholder.apply(b, args);\n\n            _this3._value += bDetails.inserted;\n            details.aggregate(bDetails);\n          }\n        });\n\n        return details;\n      }\n      /** Finds block in pos */\n\n    }, {\n      key: \"_mapPosToBlock\",\n      value: function _mapPosToBlock(pos) {\n        var accVal = '';\n\n        for (var bi = 0; bi < this._blocks.length; ++bi) {\n          var _block2 = this._blocks[bi];\n          var blockStartPos = accVal.length;\n          accVal += _block2.value;\n\n          if (pos <= accVal.length) {\n            return {\n              index: bi,\n              offset: pos - blockStartPos\n            };\n          }\n        }\n      }\n      /** */\n\n    }, {\n      key: \"_blockStartPos\",\n      value: function _blockStartPos(blockIndex) {\n        return this._blocks.slice(0, blockIndex).reduce(function (pos, b) {\n          return pos += b.value.length;\n        }, 0);\n      }\n      /** */\n\n    }, {\n      key: \"_forEachBlocksInRange\",\n      value: function _forEachBlocksInRange(fromPos) {\n        var toPos = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.value.length;\n        var fn = arguments.length > 2 ? arguments[2] : undefined;\n\n        var fromBlockIter = this._mapPosToBlock(fromPos);\n\n        if (fromBlockIter) {\n          var toBlockIter = this._mapPosToBlock(toPos); // process first block\n\n\n          var isSameBlock = toBlockIter && fromBlockIter.index === toBlockIter.index;\n          var fromBlockStartPos = fromBlockIter.offset;\n          var fromBlockEndPos = toBlockIter && isSameBlock ? toBlockIter.offset : this._blocks[fromBlockIter.index].value.length;\n          fn(this._blocks[fromBlockIter.index], fromBlockIter.index, fromBlockStartPos, fromBlockEndPos);\n\n          if (toBlockIter && !isSameBlock) {\n            // process intermediate blocks\n            for (var bi = fromBlockIter.index + 1; bi < toBlockIter.index; ++bi) {\n              fn(this._blocks[bi], bi, 0, this._blocks[bi].value.length);\n            } // process last block\n\n\n            fn(this._blocks[toBlockIter.index], toBlockIter.index, 0, toBlockIter.offset);\n          }\n        }\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"remove\",\n      value: function remove() {\n        var fromPos = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n        var toPos = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.value.length;\n\n        var removeDetails = _get(_getPrototypeOf(MaskedPattern.prototype), \"remove\", this).call(this, fromPos, toPos);\n\n        this._forEachBlocksInRange(fromPos, toPos, function (b, _, bFromPos, bToPos) {\n          removeDetails.aggregate(b.remove(bFromPos, bToPos));\n        });\n\n        return removeDetails;\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"nearestInputPos\",\n      value: function nearestInputPos(cursorPos) {\n        var direction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DIRECTION.NONE;\n        if (!this._blocks.length) return 0;\n        var cursor = new PatternCursor(this, cursorPos);\n\n        if (direction === DIRECTION.NONE) {\n          // -------------------------------------------------\n          // NONE should only go out from fixed to the right!\n          // -------------------------------------------------\n          if (cursor.pushRightBeforeInput()) return cursor.pos;\n          cursor.popState();\n          if (cursor.pushLeftBeforeInput()) return cursor.pos;\n          return this.value.length;\n        } // FORCE is only about a|* otherwise is 0\n\n\n        if (direction === DIRECTION.LEFT || direction === DIRECTION.FORCE_LEFT) {\n          // try to break fast when *|a\n          if (direction === DIRECTION.LEFT) {\n            cursor.pushRightBeforeFilled();\n            if (cursor.ok && cursor.pos === cursorPos) return cursorPos;\n            cursor.popState();\n          } // forward flow\n\n\n          cursor.pushLeftBeforeInput();\n          cursor.pushLeftBeforeRequired();\n          cursor.pushLeftBeforeFilled(); // backward flow\n\n          if (direction === DIRECTION.LEFT) {\n            cursor.pushRightBeforeInput();\n            cursor.pushRightBeforeRequired();\n            if (cursor.ok && cursor.pos <= cursorPos) return cursor.pos;\n            cursor.popState();\n            if (cursor.ok && cursor.pos <= cursorPos) return cursor.pos;\n            cursor.popState();\n          }\n\n          if (cursor.ok) return cursor.pos;\n          if (direction === DIRECTION.FORCE_LEFT) return 0;\n          cursor.popState();\n          if (cursor.ok) return cursor.pos;\n          cursor.popState();\n          if (cursor.ok) return cursor.pos; // cursor.popState();\n          // if (\n          //   cursor.pushRightBeforeInput() &&\n          //   // TODO HACK for lazy if has aligned left inside fixed and has came to the start - use start position\n          //   (!this.lazy || this.extractInput())\n          // ) return cursor.pos;\n\n          return 0;\n        }\n\n        if (direction === DIRECTION.RIGHT || direction === DIRECTION.FORCE_RIGHT) {\n          // forward flow\n          cursor.pushRightBeforeInput();\n          cursor.pushRightBeforeRequired();\n          if (cursor.pushRightBeforeFilled()) return cursor.pos;\n          if (direction === DIRECTION.FORCE_RIGHT) return this.value.length; // backward flow\n\n          cursor.popState();\n          if (cursor.ok) return cursor.pos;\n          cursor.popState();\n          if (cursor.ok) return cursor.pos;\n          return this.nearestInputPos(cursorPos, DIRECTION.LEFT);\n        }\n\n        return cursorPos;\n      }\n      /** Get block by name */\n\n    }, {\n      key: \"maskedBlock\",\n      value: function maskedBlock(name) {\n        return this.maskedBlocks(name)[0];\n      }\n      /** Get all blocks by name */\n\n    }, {\n      key: \"maskedBlocks\",\n      value: function maskedBlocks(name) {\n        var _this4 = this;\n\n        var indices = this._maskedBlocks[name];\n        if (!indices) return [];\n        return indices.map(function (gi) {\n          return _this4._blocks[gi];\n        });\n      }\n    }]);\n\n    return MaskedPattern;\n  }(Masked);\n  MaskedPattern.DEFAULTS = {\n    lazy: true,\n    placeholderChar: '_'\n  };\n  MaskedPattern.STOP_CHAR = '`';\n  MaskedPattern.ESCAPE_CHAR = '\\\\';\n  MaskedPattern.InputDefinition = PatternInputDefinition;\n  MaskedPattern.FixedDefinition = PatternFixedDefinition;\n  IMask.MaskedPattern = MaskedPattern;\n\n  /** Pattern which accepts ranges */\n\n  var MaskedRange = /*#__PURE__*/function (_MaskedPattern) {\n    _inherits(MaskedRange, _MaskedPattern);\n\n    var _super = _createSuper(MaskedRange);\n\n    function MaskedRange() {\n      _classCallCheck(this, MaskedRange);\n\n      return _super.apply(this, arguments);\n    }\n\n    _createClass(MaskedRange, [{\n      key: \"_matchFrom\",\n      get:\n      /**\n        Optionally sets max length of pattern.\n        Used when pattern length is longer then `to` param length. Pads zeros at start in this case.\n      */\n\n      /** Min bound */\n\n      /** Max bound */\n\n      /** */\n      function get() {\n        return this.maxLength - String(this.from).length;\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"_update\",\n      value: function _update(opts) {\n        // TODO type\n        opts = Object.assign({\n          to: this.to || 0,\n          from: this.from || 0,\n          maxLength: this.maxLength || 0\n        }, opts);\n        var maxLength = String(opts.to).length;\n        if (opts.maxLength != null) maxLength = Math.max(maxLength, opts.maxLength);\n        opts.maxLength = maxLength;\n        var fromStr = String(opts.from).padStart(maxLength, '0');\n        var toStr = String(opts.to).padStart(maxLength, '0');\n        var sameCharsCount = 0;\n\n        while (sameCharsCount < toStr.length && toStr[sameCharsCount] === fromStr[sameCharsCount]) {\n          ++sameCharsCount;\n        }\n\n        opts.mask = toStr.slice(0, sameCharsCount).replace(/0/g, '\\\\0') + '0'.repeat(maxLength - sameCharsCount);\n\n        _get(_getPrototypeOf(MaskedRange.prototype), \"_update\", this).call(this, opts);\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"isComplete\",\n      get: function get() {\n        return _get(_getPrototypeOf(MaskedRange.prototype), \"isComplete\", this) && Boolean(this.value);\n      }\n    }, {\n      key: \"boundaries\",\n      value: function boundaries(str) {\n        var minstr = '';\n        var maxstr = '';\n\n        var _ref = str.match(/^(\\D*)(\\d*)(\\D*)/) || [],\n            _ref2 = _slicedToArray(_ref, 3),\n            placeholder = _ref2[1],\n            num = _ref2[2];\n\n        if (num) {\n          minstr = '0'.repeat(placeholder.length) + num;\n          maxstr = '9'.repeat(placeholder.length) + num;\n        }\n\n        minstr = minstr.padEnd(this.maxLength, '0');\n        maxstr = maxstr.padEnd(this.maxLength, '9');\n        return [minstr, maxstr];\n      } // TODO str is a single char everytime\n\n      /**\n        @override\n      */\n\n    }, {\n      key: \"doPrepare\",\n      value: function doPrepare(ch) {\n        var flags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n        var details;\n\n        var _normalizePrepare = normalizePrepare(_get(_getPrototypeOf(MaskedRange.prototype), \"doPrepare\", this).call(this, ch.replace(/\\D/g, ''), flags));\n\n        var _normalizePrepare2 = _slicedToArray(_normalizePrepare, 2);\n\n        ch = _normalizePrepare2[0];\n        details = _normalizePrepare2[1];\n        if (!this.autofix || !ch) return ch;\n        var fromStr = String(this.from).padStart(this.maxLength, '0');\n        var toStr = String(this.to).padStart(this.maxLength, '0');\n        var nextVal = this.value + ch;\n        if (nextVal.length > this.maxLength) return '';\n\n        var _this$boundaries = this.boundaries(nextVal),\n            _this$boundaries2 = _slicedToArray(_this$boundaries, 2),\n            minstr = _this$boundaries2[0],\n            maxstr = _this$boundaries2[1];\n\n        if (Number(maxstr) < this.from) return fromStr[nextVal.length - 1];\n\n        if (Number(minstr) > this.to) {\n          if (this.autofix === 'pad' && nextVal.length < this.maxLength) {\n            return ['', details.aggregate(this.append(fromStr[nextVal.length - 1] + ch, flags))];\n          }\n\n          return toStr[nextVal.length - 1];\n        }\n\n        return ch;\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"doValidate\",\n      value: function doValidate() {\n        var _get2;\n\n        var str = this.value;\n        var firstNonZero = str.search(/[^0]/);\n        if (firstNonZero === -1 && str.length <= this._matchFrom) return true;\n\n        var _this$boundaries3 = this.boundaries(str),\n            _this$boundaries4 = _slicedToArray(_this$boundaries3, 2),\n            minstr = _this$boundaries4[0],\n            maxstr = _this$boundaries4[1];\n\n        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n          args[_key] = arguments[_key];\n        }\n\n        return this.from <= Number(maxstr) && Number(minstr) <= this.to && (_get2 = _get(_getPrototypeOf(MaskedRange.prototype), \"doValidate\", this)).call.apply(_get2, [this].concat(args));\n      }\n    }]);\n\n    return MaskedRange;\n  }(MaskedPattern);\n  IMask.MaskedRange = MaskedRange;\n\n  /** Date mask */\n\n  var MaskedDate = /*#__PURE__*/function (_MaskedPattern) {\n    _inherits(MaskedDate, _MaskedPattern);\n\n    var _super = _createSuper(MaskedDate);\n\n    /** Pattern mask for date according to {@link MaskedDate#format} */\n\n    /** Start date */\n\n    /** End date */\n\n    /** */\n\n    /**\n      @param {Object} opts\n    */\n    function MaskedDate(opts) {\n      _classCallCheck(this, MaskedDate);\n\n      return _super.call(this, Object.assign({}, MaskedDate.DEFAULTS, opts));\n    }\n    /**\n      @override\n    */\n\n\n    _createClass(MaskedDate, [{\n      key: \"_update\",\n      value: function _update(opts) {\n        if (opts.mask === Date) delete opts.mask;\n        if (opts.pattern) opts.mask = opts.pattern;\n        var blocks = opts.blocks;\n        opts.blocks = Object.assign({}, MaskedDate.GET_DEFAULT_BLOCKS()); // adjust year block\n\n        if (opts.min) opts.blocks.Y.from = opts.min.getFullYear();\n        if (opts.max) opts.blocks.Y.to = opts.max.getFullYear();\n\n        if (opts.min && opts.max && opts.blocks.Y.from === opts.blocks.Y.to) {\n          opts.blocks.m.from = opts.min.getMonth() + 1;\n          opts.blocks.m.to = opts.max.getMonth() + 1;\n\n          if (opts.blocks.m.from === opts.blocks.m.to) {\n            opts.blocks.d.from = opts.min.getDate();\n            opts.blocks.d.to = opts.max.getDate();\n          }\n        }\n\n        Object.assign(opts.blocks, this.blocks, blocks); // add autofix\n\n        Object.keys(opts.blocks).forEach(function (bk) {\n          var b = opts.blocks[bk];\n          if (!('autofix' in b) && 'autofix' in opts) b.autofix = opts.autofix;\n        });\n\n        _get(_getPrototypeOf(MaskedDate.prototype), \"_update\", this).call(this, opts);\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"doValidate\",\n      value: function doValidate() {\n        var _get2;\n\n        var date = this.date;\n\n        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n          args[_key] = arguments[_key];\n        }\n\n        return (_get2 = _get(_getPrototypeOf(MaskedDate.prototype), \"doValidate\", this)).call.apply(_get2, [this].concat(args)) && (!this.isComplete || this.isDateExist(this.value) && date != null && (this.min == null || this.min <= date) && (this.max == null || date <= this.max));\n      }\n      /** Checks if date is exists */\n\n    }, {\n      key: \"isDateExist\",\n      value: function isDateExist(str) {\n        return this.format(this.parse(str, this), this).indexOf(str) >= 0;\n      }\n      /** Parsed Date */\n\n    }, {\n      key: \"date\",\n      get: function get() {\n        return this.typedValue;\n      },\n      set: function set(date) {\n        this.typedValue = date;\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"typedValue\",\n      get: function get() {\n        return this.isComplete ? _get(_getPrototypeOf(MaskedDate.prototype), \"typedValue\", this) : null;\n      },\n      set: function set(value) {\n        _set(_getPrototypeOf(MaskedDate.prototype), \"typedValue\", value, this, true);\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"maskEquals\",\n      value: function maskEquals(mask) {\n        return mask === Date || _get(_getPrototypeOf(MaskedDate.prototype), \"maskEquals\", this).call(this, mask);\n      }\n    }]);\n\n    return MaskedDate;\n  }(MaskedPattern);\n  MaskedDate.DEFAULTS = {\n    pattern: 'd{.}`m{.}`Y',\n    format: function format(date) {\n      if (!date) return '';\n      var day = String(date.getDate()).padStart(2, '0');\n      var month = String(date.getMonth() + 1).padStart(2, '0');\n      var year = date.getFullYear();\n      return [day, month, year].join('.');\n    },\n    parse: function parse(str) {\n      var _str$split = str.split('.'),\n          _str$split2 = _slicedToArray(_str$split, 3),\n          day = _str$split2[0],\n          month = _str$split2[1],\n          year = _str$split2[2];\n\n      return new Date(year, month - 1, day);\n    }\n  };\n\n  MaskedDate.GET_DEFAULT_BLOCKS = function () {\n    return {\n      d: {\n        mask: MaskedRange,\n        from: 1,\n        to: 31,\n        maxLength: 2\n      },\n      m: {\n        mask: MaskedRange,\n        from: 1,\n        to: 12,\n        maxLength: 2\n      },\n      Y: {\n        mask: MaskedRange,\n        from: 1900,\n        to: 9999\n      }\n    };\n  };\n\n  IMask.MaskedDate = MaskedDate;\n\n  /**\n    Generic element API to use with mask\n    @interface\n  */\n  var MaskElement = /*#__PURE__*/function () {\n    function MaskElement() {\n      _classCallCheck(this, MaskElement);\n    }\n\n    _createClass(MaskElement, [{\n      key: \"selectionStart\",\n      get:\n      /** */\n\n      /** */\n\n      /** */\n\n      /** Safely returns selection start */\n      function get() {\n        var start;\n\n        try {\n          start = this._unsafeSelectionStart;\n        } catch (e) {}\n\n        return start != null ? start : this.value.length;\n      }\n      /** Safely returns selection end */\n\n    }, {\n      key: \"selectionEnd\",\n      get: function get() {\n        var end;\n\n        try {\n          end = this._unsafeSelectionEnd;\n        } catch (e) {}\n\n        return end != null ? end : this.value.length;\n      }\n      /** Safely sets element selection */\n\n    }, {\n      key: \"select\",\n      value: function select(start, end) {\n        if (start == null || end == null || start === this.selectionStart && end === this.selectionEnd) return;\n\n        try {\n          this._unsafeSelect(start, end);\n        } catch (e) {}\n      }\n      /** Should be overriden in subclasses */\n\n    }, {\n      key: \"_unsafeSelect\",\n      value: function _unsafeSelect(start, end) {}\n      /** Should be overriden in subclasses */\n\n    }, {\n      key: \"isActive\",\n      get: function get() {\n        return false;\n      }\n      /** Should be overriden in subclasses */\n\n    }, {\n      key: \"bindEvents\",\n      value: function bindEvents(handlers) {}\n      /** Should be overriden in subclasses */\n\n    }, {\n      key: \"unbindEvents\",\n      value: function unbindEvents() {}\n    }]);\n\n    return MaskElement;\n  }();\n  IMask.MaskElement = MaskElement;\n\n  /** Bridge between HTMLElement and {@link Masked} */\n\n  var HTMLMaskElement = /*#__PURE__*/function (_MaskElement) {\n    _inherits(HTMLMaskElement, _MaskElement);\n\n    var _super = _createSuper(HTMLMaskElement);\n\n    /** Mapping between HTMLElement events and mask internal events */\n\n    /** HTMLElement to use mask on */\n\n    /**\n      @param {HTMLInputElement|HTMLTextAreaElement} input\n    */\n    function HTMLMaskElement(input) {\n      var _this;\n\n      _classCallCheck(this, HTMLMaskElement);\n\n      _this = _super.call(this);\n      _this.input = input;\n      _this._handlers = {};\n      return _this;\n    }\n    /** */\n    // $FlowFixMe https://github.com/facebook/flow/issues/2839\n\n\n    _createClass(HTMLMaskElement, [{\n      key: \"rootElement\",\n      get: function get() {\n        var _this$input$getRootNo, _this$input$getRootNo2, _this$input;\n\n        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;\n      }\n      /**\n        Is element in focus\n        @readonly\n      */\n\n    }, {\n      key: \"isActive\",\n      get: function get() {\n        //$FlowFixMe\n        return this.input === this.rootElement.activeElement;\n      }\n      /**\n        Returns HTMLElement selection start\n        @override\n      */\n\n    }, {\n      key: \"_unsafeSelectionStart\",\n      get: function get() {\n        return this.input.selectionStart;\n      }\n      /**\n        Returns HTMLElement selection end\n        @override\n      */\n\n    }, {\n      key: \"_unsafeSelectionEnd\",\n      get: function get() {\n        return this.input.selectionEnd;\n      }\n      /**\n        Sets HTMLElement selection\n        @override\n      */\n\n    }, {\n      key: \"_unsafeSelect\",\n      value: function _unsafeSelect(start, end) {\n        this.input.setSelectionRange(start, end);\n      }\n      /**\n        HTMLElement value\n        @override\n      */\n\n    }, {\n      key: \"value\",\n      get: function get() {\n        return this.input.value;\n      },\n      set: function set(value) {\n        this.input.value = value;\n      }\n      /**\n        Binds HTMLElement events to mask internal events\n        @override\n      */\n\n    }, {\n      key: \"bindEvents\",\n      value: function bindEvents(handlers) {\n        var _this2 = this;\n\n        Object.keys(handlers).forEach(function (event) {\n          return _this2._toggleEventHandler(HTMLMaskElement.EVENTS_MAP[event], handlers[event]);\n        });\n      }\n      /**\n        Unbinds HTMLElement events to mask internal events\n        @override\n      */\n\n    }, {\n      key: \"unbindEvents\",\n      value: function unbindEvents() {\n        var _this3 = this;\n\n        Object.keys(this._handlers).forEach(function (event) {\n          return _this3._toggleEventHandler(event);\n        });\n      }\n      /** */\n\n    }, {\n      key: \"_toggleEventHandler\",\n      value: function _toggleEventHandler(event, handler) {\n        if (this._handlers[event]) {\n          this.input.removeEventListener(event, this._handlers[event]);\n          delete this._handlers[event];\n        }\n\n        if (handler) {\n          this.input.addEventListener(event, handler);\n          this._handlers[event] = handler;\n        }\n      }\n    }]);\n\n    return HTMLMaskElement;\n  }(MaskElement);\n  HTMLMaskElement.EVENTS_MAP = {\n    selectionChange: 'keydown',\n    input: 'input',\n    drop: 'drop',\n    click: 'click',\n    focus: 'focus',\n    commit: 'blur'\n  };\n  IMask.HTMLMaskElement = HTMLMaskElement;\n\n  var HTMLContenteditableMaskElement = /*#__PURE__*/function (_HTMLMaskElement) {\n    _inherits(HTMLContenteditableMaskElement, _HTMLMaskElement);\n\n    var _super = _createSuper(HTMLContenteditableMaskElement);\n\n    function HTMLContenteditableMaskElement() {\n      _classCallCheck(this, HTMLContenteditableMaskElement);\n\n      return _super.apply(this, arguments);\n    }\n\n    _createClass(HTMLContenteditableMaskElement, [{\n      key: \"_unsafeSelectionStart\",\n      get:\n      /**\n        Returns HTMLElement selection start\n        @override\n      */\n      function get() {\n        var root = this.rootElement;\n        var selection = root.getSelection && root.getSelection();\n        var anchorOffset = selection && selection.anchorOffset;\n        var focusOffset = selection && selection.focusOffset;\n\n        if (focusOffset == null || anchorOffset == null || anchorOffset < focusOffset) {\n          return anchorOffset;\n        }\n\n        return focusOffset;\n      }\n      /**\n        Returns HTMLElement selection end\n        @override\n      */\n\n    }, {\n      key: \"_unsafeSelectionEnd\",\n      get: function get() {\n        var root = this.rootElement;\n        var selection = root.getSelection && root.getSelection();\n        var anchorOffset = selection && selection.anchorOffset;\n        var focusOffset = selection && selection.focusOffset;\n\n        if (focusOffset == null || anchorOffset == null || anchorOffset > focusOffset) {\n          return anchorOffset;\n        }\n\n        return focusOffset;\n      }\n      /**\n        Sets HTMLElement selection\n        @override\n      */\n\n    }, {\n      key: \"_unsafeSelect\",\n      value: function _unsafeSelect(start, end) {\n        if (!this.rootElement.createRange) return;\n        var range = this.rootElement.createRange();\n        range.setStart(this.input.firstChild || this.input, start);\n        range.setEnd(this.input.lastChild || this.input, end);\n        var root = this.rootElement;\n        var selection = root.getSelection && root.getSelection();\n\n        if (selection) {\n          selection.removeAllRanges();\n          selection.addRange(range);\n        }\n      }\n      /**\n        HTMLElement value\n        @override\n      */\n\n    }, {\n      key: \"value\",\n      get: function get() {\n        // $FlowFixMe\n        return this.input.textContent;\n      },\n      set: function set(value) {\n        this.input.textContent = value;\n      }\n    }]);\n\n    return HTMLContenteditableMaskElement;\n  }(HTMLMaskElement);\n  IMask.HTMLContenteditableMaskElement = HTMLContenteditableMaskElement;\n\n  var _excluded$1 = [\"mask\"];\n  /** Listens to element events and controls changes between element and {@link Masked} */\n\n  var InputMask = /*#__PURE__*/function () {\n    /**\n      View element\n      @readonly\n    */\n\n    /**\n      Internal {@link Masked} model\n      @readonly\n    */\n\n    /**\n      @param {MaskElement|HTMLInputElement|HTMLTextAreaElement} el\n      @param {Object} opts\n    */\n    function InputMask(el, opts) {\n      _classCallCheck(this, InputMask);\n\n      this.el = el instanceof MaskElement ? el : el.isContentEditable && el.tagName !== 'INPUT' && el.tagName !== 'TEXTAREA' ? new HTMLContenteditableMaskElement(el) : new HTMLMaskElement(el);\n      this.masked = createMask(opts);\n      this._listeners = {};\n      this._value = '';\n      this._unmaskedValue = '';\n      this._saveSelection = this._saveSelection.bind(this);\n      this._onInput = this._onInput.bind(this);\n      this._onChange = this._onChange.bind(this);\n      this._onDrop = this._onDrop.bind(this);\n      this._onFocus = this._onFocus.bind(this);\n      this._onClick = this._onClick.bind(this);\n      this.alignCursor = this.alignCursor.bind(this);\n      this.alignCursorFriendly = this.alignCursorFriendly.bind(this);\n\n      this._bindEvents(); // refresh\n\n\n      this.updateValue();\n\n      this._onChange();\n    }\n    /** Read or update mask */\n\n\n    _createClass(InputMask, [{\n      key: \"mask\",\n      get: function get() {\n        return this.masked.mask;\n      },\n      set: function set(mask) {\n        if (this.maskEquals(mask)) return; // $FlowFixMe No ideas ... after update\n\n        if (!(mask instanceof IMask.Masked) && this.masked.constructor === maskedClass(mask)) {\n          this.masked.updateOptions({\n            mask: mask\n          });\n          return;\n        }\n\n        var masked = createMask({\n          mask: mask\n        });\n        masked.unmaskedValue = this.masked.unmaskedValue;\n        this.masked = masked;\n      }\n      /** Raw value */\n\n    }, {\n      key: \"maskEquals\",\n      value: function maskEquals(mask) {\n        var _this$masked;\n\n        return mask == null || ((_this$masked = this.masked) === null || _this$masked === void 0 ? void 0 : _this$masked.maskEquals(mask));\n      }\n    }, {\n      key: \"value\",\n      get: function get() {\n        return this._value;\n      },\n      set: function set(str) {\n        if (this.value === str) return;\n        this.masked.value = str;\n        this.updateControl();\n        this.alignCursor();\n      }\n      /** Unmasked value */\n\n    }, {\n      key: \"unmaskedValue\",\n      get: function get() {\n        return this._unmaskedValue;\n      },\n      set: function set(str) {\n        if (this.unmaskedValue === str) return;\n        this.masked.unmaskedValue = str;\n        this.updateControl();\n        this.alignCursor();\n      }\n      /** Typed unmasked value */\n\n    }, {\n      key: \"typedValue\",\n      get: function get() {\n        return this.masked.typedValue;\n      },\n      set: function set(val) {\n        if (this.masked.typedValueEquals(val)) return;\n        this.masked.typedValue = val;\n        this.updateControl();\n        this.alignCursor();\n      }\n      /**\n        Starts listening to element events\n        @protected\n      */\n\n    }, {\n      key: \"_bindEvents\",\n      value: function _bindEvents() {\n        this.el.bindEvents({\n          selectionChange: this._saveSelection,\n          input: this._onInput,\n          drop: this._onDrop,\n          click: this._onClick,\n          focus: this._onFocus,\n          commit: this._onChange\n        });\n      }\n      /**\n        Stops listening to element events\n        @protected\n       */\n\n    }, {\n      key: \"_unbindEvents\",\n      value: function _unbindEvents() {\n        if (this.el) this.el.unbindEvents();\n      }\n      /**\n        Fires custom event\n        @protected\n       */\n\n    }, {\n      key: \"_fireEvent\",\n      value: function _fireEvent(ev) {\n        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n          args[_key - 1] = arguments[_key];\n        }\n\n        var listeners = this._listeners[ev];\n        if (!listeners) return;\n        listeners.forEach(function (l) {\n          return l.apply(void 0, args);\n        });\n      }\n      /**\n        Current selection start\n        @readonly\n      */\n\n    }, {\n      key: \"selectionStart\",\n      get: function get() {\n        return this._cursorChanging ? this._changingCursorPos : this.el.selectionStart;\n      }\n      /** Current cursor position */\n\n    }, {\n      key: \"cursorPos\",\n      get: function get() {\n        return this._cursorChanging ? this._changingCursorPos : this.el.selectionEnd;\n      },\n      set: function set(pos) {\n        if (!this.el || !this.el.isActive) return;\n        this.el.select(pos, pos);\n\n        this._saveSelection();\n      }\n      /**\n        Stores current selection\n        @protected\n      */\n\n    }, {\n      key: \"_saveSelection\",\n      value: function\n        /* ev */\n      _saveSelection() {\n        if (this.value !== this.el.value) {\n          console.warn('Element value was changed outside of mask. Syncronize mask using `mask.updateValue()` to work properly.'); // eslint-disable-line no-console\n        }\n\n        this._selection = {\n          start: this.selectionStart,\n          end: this.cursorPos\n        };\n      }\n      /** Syncronizes model value from view */\n\n    }, {\n      key: \"updateValue\",\n      value: function updateValue() {\n        this.masked.value = this.el.value;\n        this._value = this.masked.value;\n      }\n      /** Syncronizes view from model value, fires change events */\n\n    }, {\n      key: \"updateControl\",\n      value: function updateControl() {\n        var newUnmaskedValue = this.masked.unmaskedValue;\n        var newValue = this.masked.value;\n        var isChanged = this.unmaskedValue !== newUnmaskedValue || this.value !== newValue;\n        this._unmaskedValue = newUnmaskedValue;\n        this._value = newValue;\n        if (this.el.value !== newValue) this.el.value = newValue;\n        if (isChanged) this._fireChangeEvents();\n      }\n      /** Updates options with deep equal check, recreates @{link Masked} model if mask type changes */\n\n    }, {\n      key: \"updateOptions\",\n      value: function updateOptions(opts) {\n        var mask = opts.mask,\n            restOpts = _objectWithoutProperties(opts, _excluded$1);\n\n        var updateMask = !this.maskEquals(mask);\n        var updateOpts = !objectIncludes(this.masked, restOpts);\n        if (updateMask) this.mask = mask;\n        if (updateOpts) this.masked.updateOptions(restOpts);\n        if (updateMask || updateOpts) this.updateControl();\n      }\n      /** Updates cursor */\n\n    }, {\n      key: \"updateCursor\",\n      value: function updateCursor(cursorPos) {\n        if (cursorPos == null) return;\n        this.cursorPos = cursorPos; // also queue change cursor for mobile browsers\n\n        this._delayUpdateCursor(cursorPos);\n      }\n      /**\n        Delays cursor update to support mobile browsers\n        @private\n      */\n\n    }, {\n      key: \"_delayUpdateCursor\",\n      value: function _delayUpdateCursor(cursorPos) {\n        var _this = this;\n\n        this._abortUpdateCursor();\n\n        this._changingCursorPos = cursorPos;\n        this._cursorChanging = setTimeout(function () {\n          if (!_this.el) return; // if was destroyed\n\n          _this.cursorPos = _this._changingCursorPos;\n\n          _this._abortUpdateCursor();\n        }, 10);\n      }\n      /**\n        Fires custom events\n        @protected\n      */\n\n    }, {\n      key: \"_fireChangeEvents\",\n      value: function _fireChangeEvents() {\n        this._fireEvent('accept', this._inputEvent);\n\n        if (this.masked.isComplete) this._fireEvent('complete', this._inputEvent);\n      }\n      /**\n        Aborts delayed cursor update\n        @private\n      */\n\n    }, {\n      key: \"_abortUpdateCursor\",\n      value: function _abortUpdateCursor() {\n        if (this._cursorChanging) {\n          clearTimeout(this._cursorChanging);\n          delete this._cursorChanging;\n        }\n      }\n      /** Aligns cursor to nearest available position */\n\n    }, {\n      key: \"alignCursor\",\n      value: function alignCursor() {\n        this.cursorPos = this.masked.nearestInputPos(this.masked.nearestInputPos(this.cursorPos, DIRECTION.LEFT));\n      }\n      /** Aligns cursor only if selection is empty */\n\n    }, {\n      key: \"alignCursorFriendly\",\n      value: function alignCursorFriendly() {\n        if (this.selectionStart !== this.cursorPos) return; // skip if range is selected\n\n        this.alignCursor();\n      }\n      /** Adds listener on custom event */\n\n    }, {\n      key: \"on\",\n      value: function on(ev, handler) {\n        if (!this._listeners[ev]) this._listeners[ev] = [];\n\n        this._listeners[ev].push(handler);\n\n        return this;\n      }\n      /** Removes custom event listener */\n\n    }, {\n      key: \"off\",\n      value: function off(ev, handler) {\n        if (!this._listeners[ev]) return this;\n\n        if (!handler) {\n          delete this._listeners[ev];\n          return this;\n        }\n\n        var hIndex = this._listeners[ev].indexOf(handler);\n\n        if (hIndex >= 0) this._listeners[ev].splice(hIndex, 1);\n        return this;\n      }\n      /** Handles view input event */\n\n    }, {\n      key: \"_onInput\",\n      value: function _onInput(e) {\n        this._inputEvent = e;\n\n        this._abortUpdateCursor(); // fix strange IE behavior\n\n\n        if (!this._selection) return this.updateValue();\n        var details = new ActionDetails( // new state\n        this.el.value, this.cursorPos, // old state\n        this.value, this._selection);\n        var oldRawValue = this.masked.rawInputValue;\n        var offset = this.masked.splice(details.startChangePos, details.removed.length, details.inserted, details.removeDirection, {\n          input: true,\n          raw: true\n        }).offset; // force align in remove direction only if no input chars were removed\n        // otherwise we still need to align with NONE (to get out from fixed symbols for instance)\n\n        var removeDirection = oldRawValue === this.masked.rawInputValue ? details.removeDirection : DIRECTION.NONE;\n        var cursorPos = this.masked.nearestInputPos(details.startChangePos + offset, removeDirection);\n        if (removeDirection !== DIRECTION.NONE) cursorPos = this.masked.nearestInputPos(cursorPos, DIRECTION.NONE);\n        this.updateControl();\n        this.updateCursor(cursorPos);\n        delete this._inputEvent;\n      }\n      /** Handles view change event and commits model value */\n\n    }, {\n      key: \"_onChange\",\n      value: function _onChange() {\n        if (this.value !== this.el.value) {\n          this.updateValue();\n        }\n\n        this.masked.doCommit();\n        this.updateControl();\n\n        this._saveSelection();\n      }\n      /** Handles view drop event, prevents by default */\n\n    }, {\n      key: \"_onDrop\",\n      value: function _onDrop(ev) {\n        ev.preventDefault();\n        ev.stopPropagation();\n      }\n      /** Restore last selection on focus */\n\n    }, {\n      key: \"_onFocus\",\n      value: function _onFocus(ev) {\n        this.alignCursorFriendly();\n      }\n      /** Restore last selection on focus */\n\n    }, {\n      key: \"_onClick\",\n      value: function _onClick(ev) {\n        this.alignCursorFriendly();\n      }\n      /** Unbind view events and removes element reference */\n\n    }, {\n      key: \"destroy\",\n      value: function destroy() {\n        this._unbindEvents(); // $FlowFixMe why not do so?\n\n\n        this._listeners.length = 0; // $FlowFixMe\n\n        delete this.el;\n      }\n    }]);\n\n    return InputMask;\n  }();\n  IMask.InputMask = InputMask;\n\n  /** Pattern which validates enum values */\n\n  var MaskedEnum = /*#__PURE__*/function (_MaskedPattern) {\n    _inherits(MaskedEnum, _MaskedPattern);\n\n    var _super = _createSuper(MaskedEnum);\n\n    function MaskedEnum() {\n      _classCallCheck(this, MaskedEnum);\n\n      return _super.apply(this, arguments);\n    }\n\n    _createClass(MaskedEnum, [{\n      key: \"_update\",\n      value:\n      /**\n        @override\n        @param {Object} opts\n      */\n      function _update(opts) {\n        // TODO type\n        if (opts.enum) opts.mask = '*'.repeat(opts.enum[0].length);\n\n        _get(_getPrototypeOf(MaskedEnum.prototype), \"_update\", this).call(this, opts);\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"doValidate\",\n      value: function doValidate() {\n        var _this = this,\n            _get2;\n\n        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n          args[_key] = arguments[_key];\n        }\n\n        return this.enum.some(function (e) {\n          return e.indexOf(_this.unmaskedValue) >= 0;\n        }) && (_get2 = _get(_getPrototypeOf(MaskedEnum.prototype), \"doValidate\", this)).call.apply(_get2, [this].concat(args));\n      }\n    }]);\n\n    return MaskedEnum;\n  }(MaskedPattern);\n  IMask.MaskedEnum = MaskedEnum;\n\n  /**\n    Number mask\n    @param {Object} opts\n    @param {string} opts.radix - Single char\n    @param {string} opts.thousandsSeparator - Single char\n    @param {Array<string>} opts.mapToRadix - Array of single chars\n    @param {number} opts.min\n    @param {number} opts.max\n    @param {number} opts.scale - Digits after point\n    @param {boolean} opts.signed - Allow negative\n    @param {boolean} opts.normalizeZeros - Flag to remove leading and trailing zeros in the end of editing\n    @param {boolean} opts.padFractionalZeros - Flag to pad trailing zeros after point in the end of editing\n  */\n  var MaskedNumber = /*#__PURE__*/function (_Masked) {\n    _inherits(MaskedNumber, _Masked);\n\n    var _super = _createSuper(MaskedNumber);\n\n    /** Single char */\n\n    /** Single char */\n\n    /** Array of single chars */\n\n    /** */\n\n    /** */\n\n    /** Digits after point */\n\n    /** */\n\n    /** Flag to remove leading and trailing zeros in the end of editing */\n\n    /** Flag to pad trailing zeros after point in the end of editing */\n    function MaskedNumber(opts) {\n      _classCallCheck(this, MaskedNumber);\n\n      return _super.call(this, Object.assign({}, MaskedNumber.DEFAULTS, opts));\n    }\n    /**\n      @override\n    */\n\n\n    _createClass(MaskedNumber, [{\n      key: \"_update\",\n      value: function _update(opts) {\n        _get(_getPrototypeOf(MaskedNumber.prototype), \"_update\", this).call(this, opts);\n\n        this._updateRegExps();\n      }\n      /** */\n\n    }, {\n      key: \"_updateRegExps\",\n      value: function _updateRegExps() {\n        // use different regexp to process user input (more strict, input suffix) and tail shifting\n        var start = '^' + (this.allowNegative ? '[+|\\\\-]?' : '');\n        var midInput = '(0|([1-9]+\\\\d*))?';\n        var mid = '\\\\d*';\n        var end = (this.scale ? '(' + escapeRegExp(this.radix) + '\\\\d{0,' + this.scale + '})?' : '') + '$';\n        this._numberRegExpInput = new RegExp(start + midInput + end);\n        this._numberRegExp = new RegExp(start + mid + end);\n        this._mapToRadixRegExp = new RegExp('[' + this.mapToRadix.map(escapeRegExp).join('') + ']', 'g');\n        this._thousandsSeparatorRegExp = new RegExp(escapeRegExp(this.thousandsSeparator), 'g');\n      }\n      /** */\n\n    }, {\n      key: \"_removeThousandsSeparators\",\n      value: function _removeThousandsSeparators(value) {\n        return value.replace(this._thousandsSeparatorRegExp, '');\n      }\n      /** */\n\n    }, {\n      key: \"_insertThousandsSeparators\",\n      value: function _insertThousandsSeparators(value) {\n        // https://stackoverflow.com/questions/2901102/how-to-print-a-number-with-commas-as-thousands-separators-in-javascript\n        var parts = value.split(this.radix);\n        parts[0] = parts[0].replace(/\\B(?=(\\d{3})+(?!\\d))/g, this.thousandsSeparator);\n        return parts.join(this.radix);\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"doPrepare\",\n      value: function doPrepare(ch) {\n        var _get2;\n\n        ch = ch.replace(this._mapToRadixRegExp, this.radix);\n\n        var noSepCh = this._removeThousandsSeparators(ch);\n\n        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n          args[_key - 1] = arguments[_key];\n        }\n\n        var _normalizePrepare = normalizePrepare((_get2 = _get(_getPrototypeOf(MaskedNumber.prototype), \"doPrepare\", this)).call.apply(_get2, [this, noSepCh].concat(args))),\n            _normalizePrepare2 = _slicedToArray(_normalizePrepare, 2),\n            prepCh = _normalizePrepare2[0],\n            details = _normalizePrepare2[1];\n\n        if (ch && !noSepCh) details.skip = true;\n        return [prepCh, details];\n      }\n      /** */\n\n    }, {\n      key: \"_separatorsCount\",\n      value: function _separatorsCount(to) {\n        var extendOnSeparators = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n        var count = 0;\n\n        for (var pos = 0; pos < to; ++pos) {\n          if (this._value.indexOf(this.thousandsSeparator, pos) === pos) {\n            ++count;\n            if (extendOnSeparators) to += this.thousandsSeparator.length;\n          }\n        }\n\n        return count;\n      }\n      /** */\n\n    }, {\n      key: \"_separatorsCountFromSlice\",\n      value: function _separatorsCountFromSlice() {\n        var slice = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._value;\n        return this._separatorsCount(this._removeThousandsSeparators(slice).length, true);\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"extractInput\",\n      value: function extractInput() {\n        var fromPos = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n        var toPos = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.value.length;\n        var flags = arguments.length > 2 ? arguments[2] : undefined;\n\n        var _this$_adjustRangeWit = this._adjustRangeWithSeparators(fromPos, toPos);\n\n        var _this$_adjustRangeWit2 = _slicedToArray(_this$_adjustRangeWit, 2);\n\n        fromPos = _this$_adjustRangeWit2[0];\n        toPos = _this$_adjustRangeWit2[1];\n        return this._removeThousandsSeparators(_get(_getPrototypeOf(MaskedNumber.prototype), \"extractInput\", this).call(this, fromPos, toPos, flags));\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"_appendCharRaw\",\n      value: function _appendCharRaw(ch) {\n        var flags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n        if (!this.thousandsSeparator) return _get(_getPrototypeOf(MaskedNumber.prototype), \"_appendCharRaw\", this).call(this, ch, flags);\n        var prevBeforeTailValue = flags.tail && flags._beforeTailState ? flags._beforeTailState._value : this._value;\n\n        var prevBeforeTailSeparatorsCount = this._separatorsCountFromSlice(prevBeforeTailValue);\n\n        this._value = this._removeThousandsSeparators(this.value);\n\n        var appendDetails = _get(_getPrototypeOf(MaskedNumber.prototype), \"_appendCharRaw\", this).call(this, ch, flags);\n\n        this._value = this._insertThousandsSeparators(this._value);\n        var beforeTailValue = flags.tail && flags._beforeTailState ? flags._beforeTailState._value : this._value;\n\n        var beforeTailSeparatorsCount = this._separatorsCountFromSlice(beforeTailValue);\n\n        appendDetails.tailShift += (beforeTailSeparatorsCount - prevBeforeTailSeparatorsCount) * this.thousandsSeparator.length;\n        appendDetails.skip = !appendDetails.rawInserted && ch === this.thousandsSeparator;\n        return appendDetails;\n      }\n      /** */\n\n    }, {\n      key: \"_findSeparatorAround\",\n      value: function _findSeparatorAround(pos) {\n        if (this.thousandsSeparator) {\n          var searchFrom = pos - this.thousandsSeparator.length + 1;\n          var separatorPos = this.value.indexOf(this.thousandsSeparator, searchFrom);\n          if (separatorPos <= pos) return separatorPos;\n        }\n\n        return -1;\n      }\n    }, {\n      key: \"_adjustRangeWithSeparators\",\n      value: function _adjustRangeWithSeparators(from, to) {\n        var separatorAroundFromPos = this._findSeparatorAround(from);\n\n        if (separatorAroundFromPos >= 0) from = separatorAroundFromPos;\n\n        var separatorAroundToPos = this._findSeparatorAround(to);\n\n        if (separatorAroundToPos >= 0) to = separatorAroundToPos + this.thousandsSeparator.length;\n        return [from, to];\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"remove\",\n      value: function remove() {\n        var fromPos = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n        var toPos = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.value.length;\n\n        var _this$_adjustRangeWit3 = this._adjustRangeWithSeparators(fromPos, toPos);\n\n        var _this$_adjustRangeWit4 = _slicedToArray(_this$_adjustRangeWit3, 2);\n\n        fromPos = _this$_adjustRangeWit4[0];\n        toPos = _this$_adjustRangeWit4[1];\n        var valueBeforePos = this.value.slice(0, fromPos);\n        var valueAfterPos = this.value.slice(toPos);\n\n        var prevBeforeTailSeparatorsCount = this._separatorsCount(valueBeforePos.length);\n\n        this._value = this._insertThousandsSeparators(this._removeThousandsSeparators(valueBeforePos + valueAfterPos));\n\n        var beforeTailSeparatorsCount = this._separatorsCountFromSlice(valueBeforePos);\n\n        return new ChangeDetails({\n          tailShift: (beforeTailSeparatorsCount - prevBeforeTailSeparatorsCount) * this.thousandsSeparator.length\n        });\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"nearestInputPos\",\n      value: function nearestInputPos(cursorPos, direction) {\n        if (!this.thousandsSeparator) return cursorPos;\n\n        switch (direction) {\n          case DIRECTION.NONE:\n          case DIRECTION.LEFT:\n          case DIRECTION.FORCE_LEFT:\n            {\n              var separatorAtLeftPos = this._findSeparatorAround(cursorPos - 1);\n\n              if (separatorAtLeftPos >= 0) {\n                var separatorAtLeftEndPos = separatorAtLeftPos + this.thousandsSeparator.length;\n\n                if (cursorPos < separatorAtLeftEndPos || this.value.length <= separatorAtLeftEndPos || direction === DIRECTION.FORCE_LEFT) {\n                  return separatorAtLeftPos;\n                }\n              }\n\n              break;\n            }\n\n          case DIRECTION.RIGHT:\n          case DIRECTION.FORCE_RIGHT:\n            {\n              var separatorAtRightPos = this._findSeparatorAround(cursorPos);\n\n              if (separatorAtRightPos >= 0) {\n                return separatorAtRightPos + this.thousandsSeparator.length;\n              }\n            }\n        }\n\n        return cursorPos;\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"doValidate\",\n      value: function doValidate(flags) {\n        var regexp = flags.input ? this._numberRegExpInput : this._numberRegExp; // validate as string\n\n        var valid = regexp.test(this._removeThousandsSeparators(this.value));\n\n        if (valid) {\n          // validate as number\n          var number = this.number;\n          valid = valid && !isNaN(number) && ( // check min bound for negative values\n          this.min == null || this.min >= 0 || this.min <= this.number) && ( // check max bound for positive values\n          this.max == null || this.max <= 0 || this.number <= this.max);\n        }\n\n        return valid && _get(_getPrototypeOf(MaskedNumber.prototype), \"doValidate\", this).call(this, flags);\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"doCommit\",\n      value: function doCommit() {\n        if (this.value) {\n          var number = this.number;\n          var validnum = number; // check bounds\n\n          if (this.min != null) validnum = Math.max(validnum, this.min);\n          if (this.max != null) validnum = Math.min(validnum, this.max);\n          if (validnum !== number) this.unmaskedValue = String(validnum);\n          var formatted = this.value;\n          if (this.normalizeZeros) formatted = this._normalizeZeros(formatted);\n          if (this.padFractionalZeros && this.scale > 0) formatted = this._padFractionalZeros(formatted);\n          this._value = formatted;\n        }\n\n        _get(_getPrototypeOf(MaskedNumber.prototype), \"doCommit\", this).call(this);\n      }\n      /** */\n\n    }, {\n      key: \"_normalizeZeros\",\n      value: function _normalizeZeros(value) {\n        var parts = this._removeThousandsSeparators(value).split(this.radix); // remove leading zeros\n\n\n        parts[0] = parts[0].replace(/^(\\D*)(0*)(\\d*)/, function (match, sign, zeros, num) {\n          return sign + num;\n        }); // add leading zero\n\n        if (value.length && !/\\d$/.test(parts[0])) parts[0] = parts[0] + '0';\n\n        if (parts.length > 1) {\n          parts[1] = parts[1].replace(/0*$/, ''); // remove trailing zeros\n\n          if (!parts[1].length) parts.length = 1; // remove fractional\n        }\n\n        return this._insertThousandsSeparators(parts.join(this.radix));\n      }\n      /** */\n\n    }, {\n      key: \"_padFractionalZeros\",\n      value: function _padFractionalZeros(value) {\n        if (!value) return value;\n        var parts = value.split(this.radix);\n        if (parts.length < 2) parts.push('');\n        parts[1] = parts[1].padEnd(this.scale, '0');\n        return parts.join(this.radix);\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"unmaskedValue\",\n      get: function get() {\n        return this._removeThousandsSeparators(this._normalizeZeros(this.value)).replace(this.radix, '.');\n      },\n      set: function set(unmaskedValue) {\n        _set(_getPrototypeOf(MaskedNumber.prototype), \"unmaskedValue\", unmaskedValue.replace('.', this.radix), this, true);\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"typedValue\",\n      get: function get() {\n        return Number(this.unmaskedValue);\n      },\n      set: function set(n) {\n        _set(_getPrototypeOf(MaskedNumber.prototype), \"unmaskedValue\", String(n), this, true);\n      }\n      /** Parsed Number */\n\n    }, {\n      key: \"number\",\n      get: function get() {\n        return this.typedValue;\n      },\n      set: function set(number) {\n        this.typedValue = number;\n      }\n      /**\n        Is negative allowed\n        @readonly\n      */\n\n    }, {\n      key: \"allowNegative\",\n      get: function get() {\n        return this.signed || this.min != null && this.min < 0 || this.max != null && this.max < 0;\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"typedValueEquals\",\n      value: function typedValueEquals(value) {\n        // handle  0 -> '' case (typed = 0 even if value = '')\n        // for details see https://github.com/uNmAnNeR/imaskjs/issues/134\n        return (_get(_getPrototypeOf(MaskedNumber.prototype), \"typedValueEquals\", this).call(this, value) || MaskedNumber.EMPTY_VALUES.includes(value) && MaskedNumber.EMPTY_VALUES.includes(this.typedValue)) && !(value === 0 && this.value === '');\n      }\n    }]);\n\n    return MaskedNumber;\n  }(Masked);\n  MaskedNumber.DEFAULTS = {\n    radix: ',',\n    thousandsSeparator: '',\n    mapToRadix: ['.'],\n    scale: 2,\n    signed: false,\n    normalizeZeros: true,\n    padFractionalZeros: false\n  };\n  MaskedNumber.EMPTY_VALUES = [].concat(_toConsumableArray(Masked.EMPTY_VALUES), [0]);\n  IMask.MaskedNumber = MaskedNumber;\n\n  /** Masking by custom Function */\n\n  var MaskedFunction = /*#__PURE__*/function (_Masked) {\n    _inherits(MaskedFunction, _Masked);\n\n    var _super = _createSuper(MaskedFunction);\n\n    function MaskedFunction() {\n      _classCallCheck(this, MaskedFunction);\n\n      return _super.apply(this, arguments);\n    }\n\n    _createClass(MaskedFunction, [{\n      key: \"_update\",\n      value:\n      /**\n        @override\n        @param {Object} opts\n      */\n      function _update(opts) {\n        if (opts.mask) opts.validate = opts.mask;\n\n        _get(_getPrototypeOf(MaskedFunction.prototype), \"_update\", this).call(this, opts);\n      }\n    }]);\n\n    return MaskedFunction;\n  }(Masked);\n  IMask.MaskedFunction = MaskedFunction;\n\n  var _excluded = [\"compiledMasks\", \"currentMaskRef\", \"currentMask\"];\n\n  /** Dynamic mask for choosing apropriate mask in run-time */\n  var MaskedDynamic = /*#__PURE__*/function (_Masked) {\n    _inherits(MaskedDynamic, _Masked);\n\n    var _super = _createSuper(MaskedDynamic);\n\n    /** Currently chosen mask */\n\n    /** Compliled {@link Masked} options */\n\n    /** Chooses {@link Masked} depending on input value */\n\n    /**\n      @param {Object} opts\n    */\n    function MaskedDynamic(opts) {\n      var _this;\n\n      _classCallCheck(this, MaskedDynamic);\n\n      _this = _super.call(this, Object.assign({}, MaskedDynamic.DEFAULTS, opts));\n      _this.currentMask = null;\n      return _this;\n    }\n    /**\n      @override\n    */\n\n\n    _createClass(MaskedDynamic, [{\n      key: \"_update\",\n      value: function _update(opts) {\n        _get(_getPrototypeOf(MaskedDynamic.prototype), \"_update\", this).call(this, opts);\n\n        if ('mask' in opts) {\n          // mask could be totally dynamic with only `dispatch` option\n          this.compiledMasks = Array.isArray(opts.mask) ? opts.mask.map(function (m) {\n            return createMask(m);\n          }) : [];\n        }\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"_appendCharRaw\",\n      value: function _appendCharRaw(ch) {\n        var flags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n        var details = this._applyDispatch(ch, flags);\n\n        if (this.currentMask) {\n          details.aggregate(this.currentMask._appendChar(ch, this.currentMaskFlags(flags)));\n        }\n\n        return details;\n      }\n    }, {\n      key: \"_applyDispatch\",\n      value: function _applyDispatch() {\n        var appended = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';\n        var flags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n        var prevValueBeforeTail = flags.tail && flags._beforeTailState != null ? flags._beforeTailState._value : this.value;\n        var inputValue = this.rawInputValue;\n        var insertValue = flags.tail && flags._beforeTailState != null ? // $FlowFixMe - tired to fight with type system\n        flags._beforeTailState._rawInputValue : inputValue;\n        var tailValue = inputValue.slice(insertValue.length);\n        var prevMask = this.currentMask;\n        var details = new ChangeDetails();\n        var prevMaskState = prevMask === null || prevMask === void 0 ? void 0 : prevMask.state; // clone flags to prevent overwriting `_beforeTailState`\n\n        this.currentMask = this.doDispatch(appended, Object.assign({}, flags)); // restore state after dispatch\n\n        if (this.currentMask) {\n          if (this.currentMask !== prevMask) {\n            // if mask changed reapply input\n            this.currentMask.reset();\n\n            if (insertValue) {\n              // $FlowFixMe - it's ok, we don't change current mask above\n              var d = this.currentMask.append(insertValue, {\n                raw: true\n              });\n              details.tailShift = d.inserted.length - prevValueBeforeTail.length;\n            }\n\n            if (tailValue) {\n              // $FlowFixMe - it's ok, we don't change current mask above\n              details.tailShift += this.currentMask.append(tailValue, {\n                raw: true,\n                tail: true\n              }).tailShift;\n            }\n          } else {\n            // Dispatch can do something bad with state, so\n            // restore prev mask state\n            this.currentMask.state = prevMaskState;\n          }\n        }\n\n        return details;\n      }\n    }, {\n      key: \"_appendPlaceholder\",\n      value: function _appendPlaceholder() {\n        var details = this._applyDispatch.apply(this, arguments);\n\n        if (this.currentMask) {\n          details.aggregate(this.currentMask._appendPlaceholder());\n        }\n\n        return details;\n      }\n      /**\n       @override\n      */\n\n    }, {\n      key: \"_appendEager\",\n      value: function _appendEager() {\n        var details = this._applyDispatch.apply(this, arguments);\n\n        if (this.currentMask) {\n          details.aggregate(this.currentMask._appendEager());\n        }\n\n        return details;\n      }\n    }, {\n      key: \"currentMaskFlags\",\n      value: function currentMaskFlags(flags) {\n        var _flags$_beforeTailSta, _flags$_beforeTailSta2;\n\n        return Object.assign({}, flags, {\n          _beforeTailState: ((_flags$_beforeTailSta = flags._beforeTailState) === null || _flags$_beforeTailSta === void 0 ? void 0 : _flags$_beforeTailSta.currentMaskRef) === this.currentMask && ((_flags$_beforeTailSta2 = flags._beforeTailState) === null || _flags$_beforeTailSta2 === void 0 ? void 0 : _flags$_beforeTailSta2.currentMask) || flags._beforeTailState\n        });\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"doDispatch\",\n      value: function doDispatch(appended) {\n        var flags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n        return this.dispatch(appended, this, flags);\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"doValidate\",\n      value: function doValidate(flags) {\n        return _get(_getPrototypeOf(MaskedDynamic.prototype), \"doValidate\", this).call(this, flags) && (!this.currentMask || this.currentMask.doValidate(this.currentMaskFlags(flags)));\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"doPrepare\",\n      value: function doPrepare(str) {\n        var flags = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n        var _normalizePrepare = normalizePrepare(_get(_getPrototypeOf(MaskedDynamic.prototype), \"doPrepare\", this).call(this, str, flags)),\n            _normalizePrepare2 = _slicedToArray(_normalizePrepare, 2),\n            s = _normalizePrepare2[0],\n            details = _normalizePrepare2[1];\n\n        if (this.currentMask) {\n          var currentDetails;\n\n          var _normalizePrepare3 = normalizePrepare(_get(_getPrototypeOf(MaskedDynamic.prototype), \"doPrepare\", this).call(this, s, this.currentMaskFlags(flags)));\n\n          var _normalizePrepare4 = _slicedToArray(_normalizePrepare3, 2);\n\n          s = _normalizePrepare4[0];\n          currentDetails = _normalizePrepare4[1];\n          details = details.aggregate(currentDetails);\n        }\n\n        return [s, details];\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"reset\",\n      value: function reset() {\n        var _this$currentMask;\n\n        (_this$currentMask = this.currentMask) === null || _this$currentMask === void 0 ? void 0 : _this$currentMask.reset();\n        this.compiledMasks.forEach(function (m) {\n          return m.reset();\n        });\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"value\",\n      get: function get() {\n        return this.currentMask ? this.currentMask.value : '';\n      },\n      set: function set(value) {\n        _set(_getPrototypeOf(MaskedDynamic.prototype), \"value\", value, this, true);\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"unmaskedValue\",\n      get: function get() {\n        return this.currentMask ? this.currentMask.unmaskedValue : '';\n      },\n      set: function set(unmaskedValue) {\n        _set(_getPrototypeOf(MaskedDynamic.prototype), \"unmaskedValue\", unmaskedValue, this, true);\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"typedValue\",\n      get: function get() {\n        return this.currentMask ? this.currentMask.typedValue : '';\n      } // probably typedValue should not be used with dynamic\n      ,\n      set: function set(value) {\n        var unmaskedValue = String(value); // double check it\n\n        if (this.currentMask) {\n          this.currentMask.typedValue = value;\n          unmaskedValue = this.currentMask.unmaskedValue;\n        }\n\n        this.unmaskedValue = unmaskedValue;\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"isComplete\",\n      get: function get() {\n        var _this$currentMask2;\n\n        return Boolean((_this$currentMask2 = this.currentMask) === null || _this$currentMask2 === void 0 ? void 0 : _this$currentMask2.isComplete);\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"isFilled\",\n      get: function get() {\n        var _this$currentMask3;\n\n        return Boolean((_this$currentMask3 = this.currentMask) === null || _this$currentMask3 === void 0 ? void 0 : _this$currentMask3.isFilled);\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"remove\",\n      value: function remove() {\n        var details = new ChangeDetails();\n\n        if (this.currentMask) {\n          var _this$currentMask4;\n\n          details.aggregate((_this$currentMask4 = this.currentMask).remove.apply(_this$currentMask4, arguments)) // update with dispatch\n          .aggregate(this._applyDispatch());\n        }\n\n        return details;\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"state\",\n      get: function get() {\n        var _this$currentMask5;\n\n        return Object.assign({}, _get(_getPrototypeOf(MaskedDynamic.prototype), \"state\", this), {\n          _rawInputValue: this.rawInputValue,\n          compiledMasks: this.compiledMasks.map(function (m) {\n            return m.state;\n          }),\n          currentMaskRef: this.currentMask,\n          currentMask: (_this$currentMask5 = this.currentMask) === null || _this$currentMask5 === void 0 ? void 0 : _this$currentMask5.state\n        });\n      },\n      set: function set(state) {\n        var compiledMasks = state.compiledMasks,\n            currentMaskRef = state.currentMaskRef,\n            currentMask = state.currentMask,\n            maskedState = _objectWithoutProperties(state, _excluded);\n\n        this.compiledMasks.forEach(function (m, mi) {\n          return m.state = compiledMasks[mi];\n        });\n\n        if (currentMaskRef != null) {\n          this.currentMask = currentMaskRef;\n          this.currentMask.state = currentMask;\n        }\n\n        _set(_getPrototypeOf(MaskedDynamic.prototype), \"state\", maskedState, this, true);\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"extractInput\",\n      value: function extractInput() {\n        var _this$currentMask6;\n\n        return this.currentMask ? (_this$currentMask6 = this.currentMask).extractInput.apply(_this$currentMask6, arguments) : '';\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"extractTail\",\n      value: function extractTail() {\n        var _this$currentMask7, _get2;\n\n        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n          args[_key] = arguments[_key];\n        }\n\n        return this.currentMask ? (_this$currentMask7 = this.currentMask).extractTail.apply(_this$currentMask7, args) : (_get2 = _get(_getPrototypeOf(MaskedDynamic.prototype), \"extractTail\", this)).call.apply(_get2, [this].concat(args));\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"doCommit\",\n      value: function doCommit() {\n        if (this.currentMask) this.currentMask.doCommit();\n\n        _get(_getPrototypeOf(MaskedDynamic.prototype), \"doCommit\", this).call(this);\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"nearestInputPos\",\n      value: function nearestInputPos() {\n        var _this$currentMask8, _get3;\n\n        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n          args[_key2] = arguments[_key2];\n        }\n\n        return this.currentMask ? (_this$currentMask8 = this.currentMask).nearestInputPos.apply(_this$currentMask8, args) : (_get3 = _get(_getPrototypeOf(MaskedDynamic.prototype), \"nearestInputPos\", this)).call.apply(_get3, [this].concat(args));\n      }\n    }, {\n      key: \"overwrite\",\n      get: function get() {\n        return this.currentMask ? this.currentMask.overwrite : _get(_getPrototypeOf(MaskedDynamic.prototype), \"overwrite\", this);\n      },\n      set: function set(overwrite) {\n        console.warn('\"overwrite\" option is not available in dynamic mask, use this option in siblings');\n      }\n    }, {\n      key: \"eager\",\n      get: function get() {\n        return this.currentMask ? this.currentMask.eager : _get(_getPrototypeOf(MaskedDynamic.prototype), \"eager\", this);\n      },\n      set: function set(eager) {\n        console.warn('\"eager\" option is not available in dynamic mask, use this option in siblings');\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"maskEquals\",\n      value: function maskEquals(mask) {\n        return Array.isArray(mask) && this.compiledMasks.every(function (m, mi) {\n          var _mask$mi;\n\n          return m.maskEquals((_mask$mi = mask[mi]) === null || _mask$mi === void 0 ? void 0 : _mask$mi.mask);\n        });\n      }\n      /**\n        @override\n      */\n\n    }, {\n      key: \"typedValueEquals\",\n      value: function typedValueEquals(value) {\n        var _this$currentMask9;\n\n        return Boolean((_this$currentMask9 = this.currentMask) === null || _this$currentMask9 === void 0 ? void 0 : _this$currentMask9.typedValueEquals(value));\n      }\n    }]);\n\n    return MaskedDynamic;\n  }(Masked);\n  MaskedDynamic.DEFAULTS = {\n    dispatch: function dispatch(appended, masked, flags) {\n      if (!masked.compiledMasks.length) return;\n      var inputValue = masked.rawInputValue; // simulate input\n\n      var inputs = masked.compiledMasks.map(function (m, index) {\n        m.reset();\n        m.append(inputValue, {\n          raw: true\n        });\n        m.append(appended, masked.currentMaskFlags(flags));\n        var weight = m.rawInputValue.length;\n        return {\n          weight: weight,\n          index: index\n        };\n      }); // pop masks with longer values first\n\n      inputs.sort(function (i1, i2) {\n        return i2.weight - i1.weight;\n      });\n      return masked.compiledMasks[inputs[0].index];\n    }\n  };\n  IMask.MaskedDynamic = MaskedDynamic;\n\n  /** Mask pipe source and destination types */\n\n  var PIPE_TYPE = {\n    MASKED: 'value',\n    UNMASKED: 'unmaskedValue',\n    TYPED: 'typedValue'\n  };\n  /** Creates new pipe function depending on mask type, source and destination options */\n\n  function createPipe(mask) {\n    var from = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : PIPE_TYPE.MASKED;\n    var to = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : PIPE_TYPE.MASKED;\n    var masked = createMask(mask);\n    return function (value) {\n      return masked.runIsolated(function (m) {\n        m[from] = value;\n        return m[to];\n      });\n    };\n  }\n  /** Pipes value through mask depending on mask type, source and destination options */\n\n  function pipe(value) {\n    for (var _len = arguments.length, pipeArgs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      pipeArgs[_key - 1] = arguments[_key];\n    }\n\n    return createPipe.apply(void 0, pipeArgs)(value);\n  }\n  IMask.PIPE_TYPE = PIPE_TYPE;\n  IMask.createPipe = createPipe;\n  IMask.pipe = pipe;\n\n  try {\n    globalThis.IMask = IMask;\n  } catch (e) {}\n\n  exports.HTMLContenteditableMaskElement = HTMLContenteditableMaskElement;\n  exports.HTMLMaskElement = HTMLMaskElement;\n  exports.InputMask = InputMask;\n  exports.MaskElement = MaskElement;\n  exports.Masked = Masked;\n  exports.MaskedDate = MaskedDate;\n  exports.MaskedDynamic = MaskedDynamic;\n  exports.MaskedEnum = MaskedEnum;\n  exports.MaskedFunction = MaskedFunction;\n  exports.MaskedNumber = MaskedNumber;\n  exports.MaskedPattern = MaskedPattern;\n  exports.MaskedRange = MaskedRange;\n  exports.MaskedRegExp = MaskedRegExp;\n  exports.PIPE_TYPE = PIPE_TYPE;\n  exports.createMask = createMask;\n  exports.createPipe = createPipe;\n  exports[\"default\"] = IMask;\n  exports.pipe = pipe;\n\n  Object.defineProperty(exports, '__esModule', { value: true });\n\n}));\n//# sourceMappingURL=imask.js.map\n"],"sourceRoot":""}