https://ayedas.com.tr/lib/js/jquery.inputmask.js

1/*!
2 * dist/jquery.inputmask
3 * https://github.com/RobinHerbots/Inputmask
4 * Copyright (c) 2010 - 2021 Robin Herbots
5 * Licensed under the MIT license
6 * Version: 5.0.6-beta.38
7 */
8!function webpackUniversalModuleDefinition(root, factory) {
9    if ("object" == typeof exports && "object" == typeof module) module.exports = factory(require("jquery")); else if ("function" == typeof define && define.amd) define(["jquery"], factory); else {
10        var a = "object" == typeof exports ? factory(require("jquery")) : factory(root.jQuery);
11        for (var i in a) ("object" == typeof exports ? exports : root)[i] = a[i];
12    }
13}(this, function (__WEBPACK_EXTERNAL_MODULE__10__) {
14    return modules = [function (module) {
15        module.exports = JSON.parse('{"BACKSPACE":8,"BACKSPACE_SAFARI":127,"DELETE":46,"DOWN":40,"END":35,"ENTER":13,"ESCAPE":27,"HOME":36,"INSERT":45,"LEFT":37,"PAGE_DOWN":34,"PAGE_UP":33,"RIGHT":39,"SPACE":32,"TAB":9,"UP":38,"X":88,"CONTROL":17,"KEY_229":229}');
16    }, function (module, exports, __webpack_require__) {
17        "use strict";
18        Object.defineProperty(exports, "__esModule", {
19            value: !0
20        }), exports.caret = caret, exports.determineLastRequiredPosition = determineLastRequiredPosition,
21            exports.determineNewCaretPosition = determineNewCaretPosition, exports.getBuffer = getBuffer,
22            exports.getBufferTemplate = getBufferTemplate, exports.getLastValidPosition = getLastValidPosition,
23            exports.isMask = isMask, exports.resetMaskSet = resetMaskSet, exports.seekNext = seekNext,
24            exports.seekPrevious = seekPrevious, exports.translatePosition = translatePosition;
25        var _validationTests = __webpack_require__(3), _validation = __webpack_require__(4);
26        function caret(input, begin, end, notranslate, isDelete) {
27            var inputmask = this, opts = this.opts, range;
28            if (void 0 === begin) return "selectionStart" in input && "selectionEnd" in input ? (begin = input.selectionStart,
29                end = input.selectionEnd) : window.getSelection ? (range = window.getSelection().getRangeAt(0),
30                    range.commonAncestorContainer.parentNode !== input && range.commonAncestorContainer !== input || (begin = range.startOffset,
31                        end = range.endOffset)) : document.selection && document.selection.createRange && (range = document.selection.createRange(),
32                            begin = 0 - range.duplicate().moveStart("character", -input.inputmask._valueGet().length),
33                            end = begin + range.text.length), {
34                    begin: notranslate ? begin : translatePosition.call(this, begin),
35                    end: notranslate ? end : translatePosition.call(this, end)
36                };
37            if (Array.isArray(begin) && (end = this.isRTL ? begin[0] : begin[1], begin = this.isRTL ? begin[1] : begin[0]),
38                void 0 !== begin.begin && (end = this.isRTL ? begin.begin : begin.end, begin = this.isRTL ? begin.end : begin.begin),
39                "number" == typeof begin) {
40                begin = notranslate ? begin : translatePosition.call(this, begin), end = notranslate ? end : translatePosition.call(this, end),
41                    end = "number" == typeof end ? end : begin;
42                var scrollCalc = parseInt(((input.ownerDocument.defaultView || window).getComputedStyle ? (input.ownerDocument.defaultView || window).getComputedStyle(input, null) : input.currentStyle).fontSize) * end;
43                if (input.scrollLeft = scrollCalc > input.scrollWidth ? scrollCalc : 0, input.inputmask.caretPos = {
44                    begin: begin,
45                    end: end
46                }, opts.insertModeVisual && !1 === opts.insertMode && begin === end && (isDelete || end++),
47                    input === (input.inputmask.shadowRoot || document).activeElement) if ("setSelectionRange" in input) input.setSelectionRange(begin, end); else if (window.getSelection) {
48                        if (range = document.createRange(), void 0 === input.firstChild || null === input.firstChild) {
49                            var textNode = document.createTextNode("");
50                            input.appendChild(textNode);
51                        }
52                        range.setStart(input.firstChild, begin < input.inputmask._valueGet().length ? begin : input.inputmask._valueGet().length),
53                            range.setEnd(input.firstChild, end < input.inputmask._valueGet().length ? end : input.inputmask._valueGet().length),
54                            range.collapse(!0);
55                        var sel = window.getSelection();
56                        sel.removeAllRanges(), sel.addRange(range);
57                    } else input.createTextRange && (range = input.createTextRange(), range.collapse(!0),
58                        range.moveEnd("character", end), range.moveStart("character", begin), range.select());
59            }
60        }
61        function determineLastRequiredPosition(returnDefinition) {
62            var inputmask = this, maskset = this.maskset, $ = this.dependencyLib, buffer = _validationTests.getMaskTemplate.call(this, !0, getLastValidPosition.call(this), !0, !0), bl = buffer.length, pos, lvp = getLastValidPosition.call(this), positions = {}, lvTest = maskset.validPositions[lvp], ndxIntlzr = void 0 !== lvTest ? lvTest.locator.slice() : void 0, testPos;
63            for (pos = lvp + 1; pos < buffer.length; pos++) testPos = _validationTests.getTestTemplate.call(this, pos, ndxIntlzr, pos - 1),
64                ndxIntlzr = testPos.locator.slice(), positions[pos] = $.extend(!0, {}, testPos);
65            var lvTestAlt = lvTest && void 0 !== lvTest.alternation ? lvTest.locator[lvTest.alternation] : void 0;
66            for (pos = bl - 1; lvp < pos && (testPos = positions[pos], (testPos.match.optionality || testPos.match.optionalQuantifier && testPos.match.newBlockMarker || lvTestAlt && (lvTestAlt !== positions[pos].locator[lvTest.alternation] && 1 != testPos.match.static || !0 === testPos.match.static && testPos.locator[lvTest.alternation] && _validation.checkAlternationMatch.call(this, testPos.locator[lvTest.alternation].toString().split(","), lvTestAlt.toString().split(",")) && "" !== _validationTests.getTests.call(this, pos)[0].def)) && buffer[pos] === _validationTests.getPlaceholder.call(this, pos, testPos.match)); pos--) bl--;
67            return returnDefinition ? {
68                l: bl,
69                def: positions[bl] ? positions[bl].match : void 0
70            } : bl;
71        }
72        function determineNewCaretPosition(selectedCaret, tabbed, positionCaretOnClick) {
73            var inputmask = this, maskset = this.maskset, opts = this.opts;
74            function doRadixFocus(clickPos) {
75                if ("" !== opts.radixPoint && 0 !== opts.digits) {
76                    var vps = maskset.validPositions;
77                    if (void 0 === vps[clickPos] || vps[clickPos].input === _validationTests.getPlaceholder.call(inputmask, clickPos)) {
78                        if (clickPos < seekNext.call(inputmask, -1)) return !0;
79                        var radixPos = getBuffer.call(inputmask).indexOf(opts.radixPoint);
80                        if (-1 !== radixPos) {
81                            for (var vp in vps) if (vps[vp] && radixPos < vp && vps[vp].input !== _validationTests.getPlaceholder.call(inputmask, vp)) return !1;
82                            return !0;
83                        }
84                    }
85                }
86                return !1;
87            }
88            if (tabbed && (inputmask.isRTL ? selectedCaret.end = selectedCaret.begin : selectedCaret.begin = selectedCaret.end),
89                selectedCaret.begin === selectedCaret.end) {
90                switch (positionCaretOnClick = positionCaretOnClick || opts.positionCaretOnClick,
91                positionCaretOnClick) {
92                    case "none":
93                        break;
94
95                    case "select":
96                        selectedCaret = {
97                            begin: 0,
98                            end: getBuffer.call(inputmask).length
99                        };
100                        break;
101
102                    case "ignore":
103                        selectedCaret.end = selectedCaret.begin = seekNext.call(inputmask, getLastValidPosition.call(inputmask));
104                        break;
105
106                    case "radixFocus":
107                        if (doRadixFocus(selectedCaret.begin)) {
108                            var radixPos = getBuffer.call(inputmask).join("").indexOf(opts.radixPoint);
109                            selectedCaret.end = selectedCaret.begin = opts.numericInput ? seekNext.call(inputmask, radixPos) : radixPos;
110                            break;
111                        }
112
113                    default:
114                        var clickPosition = selectedCaret.begin, lvclickPosition = getLastValidPosition.call(inputmask, clickPosition, !0), lastPosition = seekNext.call(inputmask, -1 !== lvclickPosition || isMask.call(inputmask, 0) ? lvclickPosition : -1);
115                        if (clickPosition <= lastPosition) selectedCaret.end = selectedCaret.begin = isMask.call(inputmask, clickPosition, !1, !0) ? clickPosition : seekNext.call(inputmask, clickPosition); else {
116                            var lvp = maskset.validPositions[lvclickPosition], tt = _validationTests.getTestTemplate.call(inputmask, lastPosition, lvp ? lvp.match.locator : void 0, lvp), placeholder = _validationTests.getPlaceholder.call(inputmask, lastPosition, tt.match);
117                            if ("" !== placeholder && getBuffer.call(inputmask)[lastPosition] !== placeholder && !0 !== tt.match.optionalQuantifier && !0 !== tt.match.newBlockMarker || !isMask.call(inputmask, lastPosition, opts.keepStatic, !0) && tt.match.def === placeholder) {
118                                var newPos = seekNext.call(inputmask, lastPosition);
119                                (newPos <= clickPosition || clickPosition === lastPosition) && (lastPosition = newPos);
120                            }
121                            selectedCaret.end = selectedCaret.begin = lastPosition;
122                        }
123                }
124                return selectedCaret;
125            }
126        }
127        function getBuffer(noCache) {
128            var inputmask = this, maskset = this.maskset;
129            return void 0 !== maskset.buffer && !0 !== noCache || (maskset.buffer = _validationTests.getMaskTemplate.call(this, !0, getLastValidPosition.call(this), !0),
130                void 0 === maskset._buffer && (maskset._buffer = maskset.buffer.slice())), maskset.buffer;
131        }
132        function getBufferTemplate() {
133            var inputmask = this, maskset = this.maskset;
134            return void 0 === maskset._buffer && (maskset._buffer = _validationTests.getMaskTemplate.call(this, !1, 1),
135                void 0 === maskset.buffer && (maskset.buffer = maskset._buffer.slice())), maskset._buffer;
136        }
137        function getLastValidPosition(closestTo, strict, validPositions) {
138            var maskset = this.maskset, before = -1, after = -1, valids = validPositions || maskset.validPositions;
139            for (var posNdx in void 0 === closestTo && (closestTo = -1), valids) {
140                var psNdx = parseInt(posNdx);
141                valids[psNdx] && (strict || !0 !== valids[psNdx].generatedInput) && (psNdx <= closestTo && (before = psNdx),
142                    closestTo <= psNdx && (after = psNdx));
143            }
144            return -1 === before || before == closestTo ? after : -1 == after ? before : closestTo - before < after - closestTo ? before : after;
145        }
146        function isMask(pos, strict, fuzzy) {
147            var inputmask = this, maskset = this.maskset, test = _validationTests.getTestTemplate.call(this, pos).match;
148            if ("" === test.def && (test = _validationTests.getTest.call(this, pos).match),
149                !0 !== test.static) return test.fn;
150            if (!0 === fuzzy && void 0 !== maskset.validPositions[pos] && !0 !== maskset.validPositions[pos].generatedInput) return !0;
151            if (!0 !== strict && -1 < pos) {
152                if (fuzzy) {
153                    var tests = _validationTests.getTests.call(this, pos);
154                    return tests.length > 1 + ("" === tests[tests.length - 1].match.def ? 1 : 0);
155                }
156                var testTemplate = _validationTests.determineTestTemplate.call(this, pos, _validationTests.getTests.call(this, pos)), testPlaceHolder = _validationTests.getPlaceholder.call(this, pos, testTemplate.match);
157                return testTemplate.match.def !== testPlaceHolder;
158            }
159            return !1;
160        }
161        function resetMaskSet(soft) {
162            var maskset = this.maskset;
163            maskset.buffer = void 0, !0 !== soft && (maskset.validPositions = {}, maskset.p = 0);
164        }
165        function seekNext(pos, newBlock, fuzzy) {
166            var inputmask = this;
167            void 0 === fuzzy && (fuzzy = !0);
168            for (var position = pos + 1; "" !== _validationTests.getTest.call(this, position).match.def && (!0 === newBlock && (!0 !== _validationTests.getTest.call(this, position).match.newBlockMarker || !isMask.call(this, position, void 0, !0)) || !0 !== newBlock && !isMask.call(this, position, void 0, fuzzy));) position++;
169            return position;
170        }
171        function seekPrevious(pos, newBlock) {
172            var inputmask = this, position = pos - 1;
173            if (pos <= 0) return 0;
174            for (; 0 < position && (!0 === newBlock && (!0 !== _validationTests.getTest.call(this, position).match.newBlockMarker || !isMask.call(this, position, void 0, !0)) || !0 !== newBlock && !isMask.call(this, position, void 0, !0));) position--;
175            return position;
176        }
177        function translatePosition(pos) {
178            var inputmask = this, opts = this.opts, el = this.el;
179            return !this.isRTL || "number" != typeof pos || opts.greedy && "" === opts.placeholder || !el || (pos = Math.abs(this._valueGet().length - pos)),
180                pos;
181        }
182    }, function (module, exports, __webpack_require__) {
183        "use strict";
184        Object.defineProperty(exports, "__esModule", {
185            value: !0
186        }), exports.default = void 0, __webpack_require__(16), __webpack_require__(17);
187        var _mask = __webpack_require__(18), _inputmask = _interopRequireDefault(__webpack_require__(12)), _window = _interopRequireDefault(__webpack_require__(8)), _maskLexer = __webpack_require__(19), _validationTests = __webpack_require__(3), _positioning = __webpack_require__(1), _validation = __webpack_require__(4), _inputHandling = __webpack_require__(5), _eventruler = __webpack_require__(11), _definitions = _interopRequireDefault(__webpack_require__(21)), _defaults = _interopRequireDefault(__webpack_require__(22)), _canUseDOM = _interopRequireDefault(__webpack_require__(9));
188        function _typeof(obj) {
189            return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function _typeof(obj) {
190                return typeof obj;
191            } : function _typeof(obj) {
192                return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
193            }, _typeof(obj);
194        }
195        function _interopRequireDefault(obj) {
196            return obj && obj.__esModule ? obj : {
197                default: obj
198            };
199        }
200        var document = _window.default.document, dataKey = "_inputmask_opts";
201        function Inputmask(alias, options, internal) {
202            if (_canUseDOM.default) {
203                if (!(this instanceof Inputmask)) return new Inputmask(alias, options, internal);
204                this.dependencyLib = _inputmask.default, this.el = void 0, this.events = {}, this.maskset = void 0,
205                    !0 !== internal && ("[object Object]" === Object.prototype.toString.call(alias) ? options = alias : (options = options || {},
206                        alias && (options.alias = alias)), this.opts = _inputmask.default.extend(!0, {}, this.defaults, options),
207                        this.noMasksCache = options && void 0 !== options.definitions, this.userOptions = options || {},
208                        resolveAlias(this.opts.alias, options, this.opts)), this.refreshValue = !1, this.undoValue = void 0,
209                    this.$el = void 0, this.skipKeyPressEvent = !1, this.skipInputEvent = !1, this.validationEvent = !1,
210                    this.ignorable = !1, this.maxLength, this.mouseEnter = !1, this.originalPlaceholder = void 0,
211                    this.isComposing = !1;
212            }
213        }
214        function resolveAlias(aliasStr, options, opts) {
215            var aliasDefinition = Inputmask.prototype.aliases[aliasStr];
216            return aliasDefinition ? (aliasDefinition.alias && resolveAlias(aliasDefinition.alias, void 0, opts),
217                _inputmask.default.extend(!0, opts, aliasDefinition), _inputmask.default.extend(!0, opts, options),
218                !0) : (null === opts.mask && (opts.mask = aliasStr), !1);
219        }
220        function importAttributeOptions(npt, opts, userOptions, dataAttribute) {
221            function importOption(option, optionData) {
222                var attrOption = "" === dataAttribute ? option : dataAttribute + "-" + option;
223                optionData = void 0 !== optionData ? optionData : npt.getAttribute(attrOption),
224                    null !== optionData && ("string" == typeof optionData && (0 === option.indexOf("on") ? optionData = _window.default[optionData] : "false" === optionData ? optionData = !1 : "true" === optionData && (optionData = !0)),
225                        userOptions[option] = optionData);
226            }
227            if (!0 === opts.importDataAttributes) {
228                var attrOptions = npt.getAttribute(dataAttribute), option, dataoptions, optionData, p;
229                if (attrOptions && "" !== attrOptions && (attrOptions = attrOptions.replace(/'/g, '"'),
230                    dataoptions = JSON.parse("{" + attrOptions + "}")), dataoptions) for (p in optionData = void 0,
231                        dataoptions) if ("alias" === p.toLowerCase()) {
232                            optionData = dataoptions[p];
233                            break;
234                        }
235                for (option in importOption("alias", optionData), userOptions.alias && resolveAlias(userOptions.alias, userOptions, opts),
236                    opts) {
237                    if (dataoptions) for (p in optionData = void 0, dataoptions) if (p.toLowerCase() === option.toLowerCase()) {
238                        optionData = dataoptions[p];
239                        break;
240                    }
241                    importOption(option, optionData);
242                }
243            }
244            return _inputmask.default.extend(!0, opts, userOptions), "rtl" !== npt.dir && !opts.rightAlign || (npt.style.textAlign = "right"),
245                "rtl" !== npt.dir && !opts.numericInput || (npt.dir = "ltr", npt.removeAttribute("dir"),
246                    opts.isRTL = !0), Object.keys(userOptions).length;
247        }
248        Inputmask.prototype = {
249            dataAttribute: "data-inputmask",
250            defaults: _defaults.default,
251            definitions: _definitions.default,
252            aliases: {},
253            masksCache: {},
254            get isRTL() {
255                return this.opts.isRTL || this.opts.numericInput;
256            },
257            mask: function mask(elems) {
258                var that = this;
259                return "string" == typeof elems && (elems = document.getElementById(elems) || document.querySelectorAll(elems)),
260                    elems = elems.nodeName ? [elems] : Array.isArray(elems) ? elems : Array.from(elems),
261                    elems.forEach(function (el, ndx) {
262                        var scopedOpts = _inputmask.default.extend(!0, {}, that.opts);
263                        if (importAttributeOptions(el, scopedOpts, _inputmask.default.extend(!0, {}, that.userOptions), that.dataAttribute)) {
264                            var maskset = (0, _maskLexer.generateMaskSet)(scopedOpts, that.noMasksCache);
265                            void 0 !== maskset && (void 0 !== el.inputmask && (el.inputmask.opts.autoUnmask = !0,
266                                el.inputmask.remove()), el.inputmask = new Inputmask(void 0, void 0, !0), el.inputmask.opts = scopedOpts,
267                                el.inputmask.noMasksCache = that.noMasksCache, el.inputmask.userOptions = _inputmask.default.extend(!0, {}, that.userOptions),
268                                el.inputmask.el = el, el.inputmask.$el = (0, _inputmask.default)(el), el.inputmask.maskset = maskset,
269                                _inputmask.default.data(el, dataKey, that.userOptions), _mask.mask.call(el.inputmask));
270                        }
271                    }), elems && elems[0] && elems[0].inputmask || this;
272            },
273            option: function option(options, noremask) {
274                return "string" == typeof options ? this.opts[options] : "object" === _typeof(options) ? (_inputmask.default.extend(this.userOptions, options),
275                    this.el && !0 !== noremask && this.mask(this.el), this) : void 0;
276            },
277            unmaskedvalue: function unmaskedvalue(value) {
278                if (this.maskset = this.maskset || (0, _maskLexer.generateMaskSet)(this.opts, this.noMasksCache),
279                    void 0 === this.el || void 0 !== value) {
280                    var valueBuffer = ("function" == typeof this.opts.onBeforeMask && this.opts.onBeforeMask.call(this, value, this.opts) || value).split("");
281                    _inputHandling.checkVal.call(this, void 0, !1, !1, valueBuffer), "function" == typeof this.opts.onBeforeWrite && this.opts.onBeforeWrite.call(this, void 0, _positioning.getBuffer.call(this), 0, this.opts);
282                }
283                return _inputHandling.unmaskedvalue.call(this, this.el);
284            },
285            remove: function remove() {
286                if (this.el) {
287                    _inputmask.default.data(this.el, dataKey, null);
288                    var cv = this.opts.autoUnmask ? (0, _inputHandling.unmaskedvalue)(this.el) : this._valueGet(this.opts.autoUnmask), valueProperty;
289                    cv !== _positioning.getBufferTemplate.call(this).join("") ? this._valueSet(cv, this.opts.autoUnmask) : this._valueSet(""),
290                        _eventruler.EventRuler.off(this.el), Object.getOwnPropertyDescriptor && Object.getPrototypeOf ? (valueProperty = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(this.el), "value"),
291                            valueProperty && this.__valueGet && Object.defineProperty(this.el, "value", {
292                                get: this.__valueGet,
293                                set: this.__valueSet,
294                                configurable: !0
295                            })) : document.__lookupGetter__ && this.el.__lookupGetter__("value") && this.__valueGet && (this.el.__defineGetter__("value", this.__valueGet),
296                                this.el.__defineSetter__("value", this.__valueSet)), this.el.inputmask = void 0;
297                }
298                return this.el;
299            },
300            getemptymask: function getemptymask() {
301                return this.maskset = this.maskset || (0, _maskLexer.generateMaskSet)(this.opts, this.noMasksCache),
302                    _positioning.getBufferTemplate.call(this).join("");
303            },
304            hasMaskedValue: function hasMaskedValue() {
305                return !this.opts.autoUnmask;
306            },
307            isComplete: function isComplete() {
308                return this.maskset = this.maskset || (0, _maskLexer.generateMaskSet)(this.opts, this.noMasksCache),
309                    _validation.isComplete.call(this, _positioning.getBuffer.call(this));
310            },
311            getmetadata: function getmetadata() {
312                if (this.maskset = this.maskset || (0, _maskLexer.generateMaskSet)(this.opts, this.noMasksCache),
313                    Array.isArray(this.maskset.metadata)) {
314                    var maskTarget = _validationTests.getMaskTemplate.call(this, !0, 0, !1).join("");
315                    return this.maskset.metadata.forEach(function (mtdt) {
316                        return mtdt.mask !== maskTarget || (maskTarget = mtdt, !1);
317                    }), maskTarget;
318                }
319                return this.maskset.metadata;
320            },
321            isValid: function isValid(value) {
322                if (this.maskset = this.maskset || (0, _maskLexer.generateMaskSet)(this.opts, this.noMasksCache),
323                    value) {
324                    var valueBuffer = ("function" == typeof this.opts.onBeforeMask && this.opts.onBeforeMask.call(this, value, this.opts) || value).split("");
325                    _inputHandling.checkVal.call(this, void 0, !0, !1, valueBuffer);
326                } else value = this.isRTL ? _positioning.getBuffer.call(this).slice().reverse().join("") : _positioning.getBuffer.call(this).join("");
327                for (var buffer = _positioning.getBuffer.call(this), rl = _positioning.determineLastRequiredPosition.call(this), lmib = buffer.length - 1; rl < lmib && !_positioning.isMask.call(this, lmib); lmib--);
328                return buffer.splice(rl, lmib + 1 - rl), _validation.isComplete.call(this, buffer) && value === (this.isRTL ? _positioning.getBuffer.call(this).slice().reverse().join("") : _positioning.getBuffer.call(this).join(""));
329            },
330            format: function format(value, metadata) {
331                this.maskset = this.maskset || (0, _maskLexer.generateMaskSet)(this.opts, this.noMasksCache);
332                var valueBuffer = ("function" == typeof this.opts.onBeforeMask && this.opts.onBeforeMask.call(this, value, this.opts) || value).split("");
333                _inputHandling.checkVal.call(this, void 0, !0, !1, valueBuffer);
334                var formattedValue = this.isRTL ? _positioning.getBuffer.call(this).slice().reverse().join("") : _positioning.getBuffer.call(this).join("");
335                return metadata ? {
336                    value: formattedValue,
337                    metadata: this.getmetadata()
338                } : formattedValue;
339            },
340            setValue: function setValue(value) {
341                this.el && (0, _inputmask.default)(this.el).trigger("setvalue", [value]);
342            },
343            analyseMask: _maskLexer.analyseMask
344        }, Inputmask.extendDefaults = function (options) {
345            _inputmask.default.extend(!0, Inputmask.prototype.defaults, options);
346        }, Inputmask.extendDefinitions = function (definition) {
347            _inputmask.default.extend(!0, Inputmask.prototype.definitions, definition);
348        }, Inputmask.extendAliases = function (alias) {
349            _inputmask.default.extend(!0, Inputmask.prototype.aliases, alias);
350        }, Inputmask.format = function (value, options, metadata) {
351            return Inputmask(options).format(value, metadata);
352        }, Inputmask.unmask = function (value, options) {
353            return Inputmask(options).unmaskedvalue(value);
354        }, Inputmask.isValid = function (value, options) {
355            return Inputmask(options).isValid(value);
356        }, Inputmask.remove = function (elems) {
357            "string" == typeof elems && (elems = document.getElementById(elems) || document.querySelectorAll(elems)),
358                elems = elems.nodeName ? [elems] : elems, elems.forEac

432 i++) if ("-" === pattern.charAt(i)) for (end = pattern.charCodeAt(i + 1); ++start < end;) expanded.push(String.fromCharCode(start)); else start = pattern.charCodeAt(i),
433                    expanded.push(pattern.charAt(i));
434                return expanded.join("");
435            }
436            return source.match.def === target.match.nativeDef || !(!(opts.regex || source.match.fn instanceof RegExp && target.match.fn instanceof RegExp) || !0 === source.match.static || !0 === target.match.static) && -1 !== expand(target.match.fn.toString().replace(/[[\]/]/g, "")).indexOf(expand(source.match.fn.toString().replace(/[[\]/]/g, "")));
437        }
438        function getTests(pos, ndxIntlzr, tstPs) {
439            var inputmask = this, $ = this.dependencyLib, maskset = this.maskset, opts = this.opts, el = this.el, maskTokens = maskset.maskToken, testPos = ndxIntlzr ? tstPs : 0, ndxInitializer = ndxIntlzr ? ndxIntlzr.slice() : [0], matches = [], insertStop = !1, latestMatch, cacheDependency = ndxIntlzr ? ndxIntlzr.join("") : "";
440            function resolveTestFromToken(maskToken, ndxInitializer, loopNdx, quantifierRecurse) {
441                function handleMatch(match, loopNdx, quantifierRecurse) {
442                    function isFirstMatch(latestMatch, tokenGroup) {
443                        var firstMatch = 0 === tokenGroup.matches.indexOf(latestMatch);
444                        return firstMatch || tokenGroup.matches.every(function (match, ndx) {
445                            return !0 === match.isQuantifier ? firstMatch = isFirstMatch(latestMatch, tokenGroup.matches[ndx - 1]) : Object.prototype.hasOwnProperty.call(match, "matches") && (firstMatch = isFirstMatch(latestMatch, match)),
446                                !firstMatch;
447                        }), firstMatch;
448                    }
449                    function resolveNdxInitializer(pos, alternateNdx, targetAlternation) {
450                        var bestMatch, indexPos;
451                        if ((maskset.tests[pos] || maskset.validPositions[pos]) && (maskset.tests[pos] || [maskset.validPositions[pos]]).every(function (lmnt, ndx) {
452                            if (lmnt.mloc[alternateNdx]) return bestMatch = lmnt, !1;
453                            var alternation = void 0 !== targetAlternation ? targetAlternation : lmnt.alternation, ndxPos = void 0 !== lmnt.locator[alternation] ? lmnt.locator[alternation].toString().indexOf(alternateNdx) : -1;
454                            return (void 0 === indexPos || ndxPos < indexPos) && -1 !== ndxPos && (bestMatch = lmnt,
455                                indexPos = ndxPos), !0;
456                        }), bestMatch) {
457                            var bestMatchAltIndex = bestMatch.locator[bestMatch.alternation], locator = bestMatch.mloc[alternateNdx] || bestMatch.mloc[bestMatchAltIndex] || bestMatch.locator;
458                            return locator.slice((void 0 !== targetAlternation ? targetAlternation : bestMatch.alternation) + 1);
459                        }
460                        return void 0 !== targetAlternation ? resolveNdxInitializer(pos, alternateNdx) : void 0;
461                    }
462                    function staticCanMatchDefinition(source, target) {
463                        return !0 === source.match.static && !0 !== target.match.static && target.match.fn.test(source.match.def, maskset, pos, !1, opts, !1);
464                    }
465                    function setMergeLocators(targetMatch, altMatch) {
466                        var alternationNdx = targetMatch.alternation, shouldMerge = void 0 === altMatch || alternationNdx === altMatch.alternation && -1 === targetMatch.locator[alternationNdx].toString().indexOf(altMatch.locator[alternationNdx]);
467                        if (!shouldMerge && alternationNdx > altMatch.alternation) for (var i = altMatch.alternation; i < alternationNdx; i++) if (targetMatch.locator[i] !== altMatch.locator[i]) {
468                            alternationNdx = i, shouldMerge = !0;
469                            break;
470                        }
471                        if (shouldMerge) {
472                            targetMatch.mloc = targetMatch.mloc || {};
473                            var locNdx = targetMatch.locator[alternationNdx];
474                            if (void 0 !== locNdx) {
475                                if ("string" == typeof locNdx && (locNd

757            strict = !0 === strict;
758            var maskPos = pos;
759            function processCommandObject(commandObj) {
760                if (void 0 !== commandObj) {
761                    if (void 0 !== commandObj.remove && (Array.isArray(commandObj.remove) || (commandObj.remove = [commandObj.remove]),
762                        commandObj.remove.sort(function (a, b) {
763                            return b.pos - a.pos;
764                        }).forEach(function (lmnt) {
765                            revalidateMask.call(inputmask, {
766                                begin: lmnt,
767                                end: lmnt + 1
768                            });
769                        }), commandObj.remove = void 0), void 0 !== commandObj.insert && (Array.isArray(commandObj.insert) || (commandObj.insert = [commandObj.insert]),
770                            commandObj.insert.sort(function (a, b) {
771                                return a.pos - b.pos;
772                            }).forEach(function (lmnt) {
773                                "" !== lmnt.c && isValid.call(inputmask, lmnt.pos, lmnt.c, void 0 === lmnt.strict || lmnt.strict, void 0 !== lmnt.fromIsValid ? lmnt.fromIsValid : fromIsValid);
774                            }), commandObj.insert = void 0), commandObj.refreshFromBuffer && commandObj.buffer) {
775                        var refresh = commandObj.refreshFromBuffer;
776                        refreshFromBuffer.call(inputmask, !0 === refresh ? refresh : refresh.start, refresh.end, commandObj.buffer),
777                            commandObj.refreshFromBuffer = void 0;
778                    }
779                    void 0 !== commandObj.rewritePosition && (maskPos = commandObj.rewritePosition,
780                        commandObj = !0);
781                }
782                return commandObj;
783            }
784            function _isValid(position, c, strict) {
785                var rslt = !1;
786                return _validationTests.getTests.call(inputmask, position).every(function (tst, ndx) {
787                    var test = tst.match;
788                    if (_positioning.getBuffer.call(inputmask, !0), rslt = null != test.fn ? test.fn.test(c, maskset, position, strict, opts, isSelection(pos)) : (c === test.def || c === opts.skipOptionalPartCharacter) && "" !== test.def && {
789                        c: _validationTests.getPlaceholder.call(inputmask, position, test, !0) || test.def,
790                        pos: position
791                    }, !1 === rslt) return !0;
792                    var elem = void 0 !== rslt.c ? rslt.c : c, validatedPos = position;
793                    return elem = elem === opts.skipOptionalPartCharacter && !0 === test.static ? _validationTests.getPlaceholder.call(inputmask, position, test, !0) || test.def : elem,
794                        rslt = processCommandObject(rslt), !0 !== rslt && void 0 !== rslt.pos && rslt.pos !== position && (validatedPos = rslt.pos),
795                        !0 !== rslt && void 0 === rslt.pos && void 0 === rslt.c || !1 === revalidateMask.call(inputmask, pos, $.extend({}, tst, {
796                            input: casing.call(inputmask, elem, test, validatedPos)
797                        }), fromIsValid, validatedPos) && (rslt = !1), !1;
798                }), rslt;
799            }
800            void 0 !== pos.begin && (maskPos = inputmask.isRTL ? pos.end : pos.begin);
801            var result = !0, positionsClone = $.extend(!0, {}, maskset.validPositions);
802            if (!1 === opts.keepStatic && void 0 !== maskset.excludes[maskPos] && !0 !== fromAlternate && !0 !== fromIsValid) for (var i = maskPos; i < (inputmask.isRTL ? pos.begin : pos.end); i++) void 0 !== maskset.excludes[i] && (maskset.excludes[i] = void 0,
803                delete maskset.tests[i]);
804            if ("function" == typeof opts.preValidation && !0 !== fromIsValid && !0 !== validateOnly && (result = opts.preValidation.call(inputmask, _positioning.getBuffer.call(inputmask), maskPos, c, isSelection(pos), opts, maskset, pos, strict || fromAlternate),
805                result = processCommandObject(result)), !0 === result) {
806                if (void 0 === inputmask.maxLength || maskPos < _positioning.translatePosition.call(inputmask, inputmask.maxLength)) {
807                    if (result = _isValid(maskPos, c, strict), (!strict || !0 === fromIsValid) && !1 === result && !0 !== validateOnly) {
808                        var currentPosValid = maskset.validPositions[maskPos];
809                        if (!currentPosValid || !0 !== currentPosValid.match.static || currentPosValid.match.def !== c && c !== opts.skipOptionalPartCharacter) {
810                            if (opts.insertMode || void 0 === maskset.validPositions[_positioning.seekNext.call(inputmask, maskPos)] || pos.end > maskPos) {
811                                var skip = !1;
812                                if (maskset.jitOffset[maskPos] && void 0 === maskset.validPositions[_positioning.seekNext.call(inputmask, maskPos)] && (result = isValid.call(inputmask, maskPos + maskset.jitOffset[maskPos], c, !0),
813                                    !1 !== result && (!0 !== fromAlternate && (result.caret = maskPos), skip = !0)),
814                                    pos.end > maskPos && (maskset.validPositions[maskPos] = void 0), !skip && !_positioning.isMask.call(inputmask, maskPos, opts.keepStatic && 0 === maskPos)) for (var nPos = maskPos + 1, snPos = _positioning.seekNext.call(inputmask, maskPos, !1, 0 !== maskPos); nPos <= snPos; nPos++) if (result = _isValid(nPos, c, strict),
815                                        !1 !== result) {
816                                        result = trackbackPositions.call(inputmask, maskPos, void 0 !== result.pos ? result.pos : nPos) || result,
817                                            maskPos = nPos;
818                                        break;
819                                    }
820                            }
821                        } else result = {
822                            caret: _positioning.seekNext.call(inputmask, maskPos)
823                        };
824                    }
825                } else result = !1;
826                !1 !== result || !opts.keepStatic || !isComplete.call(inputmask, _positioning.getBuffer.call(inputmask)) && 0 !== maskPos || strict || !0 === fromAlternate ? isSelection(pos) && maskset.tests[maskPos] && 1 < maskset.tests[maskPos].length && opts.keepStatic && !strict && !0 !== fromAlternate && (result = alternate.call(inputmask, !0)) : result = alternate.call(inputmask, maskPos, c, strict, fromIsValid, void 0, pos),
827                    !0 === result && (result = {
828                        pos: maskPos
829                    });
830            }
831            if ("function" == typeof opts.postValidation && !0 !== fromIsValid && !0 !== validateOnly) {
832                var postResult = opts.postValidation.call(inputmask, _positioning.getBuffer.call(inputmask, !0), void 0 !== pos.begin ? inputmask.isRTL ? pos.end : pos.begin : pos, c, result, opts, maskset, strict, fromCheckval);
833                void 0 !== postResult && (result = !0 === postResult ? result : postResult);
834            }
835            result && void 0 === result.pos && (result.pos = maskPos), !1 === result || !0 === validateOnly ? (_positioning.resetMaskSet.call(inputmask, !0),
836                maskset.validPositions = $.extend(!0, {}, positionsClone)) : trackbackPositions.call(inputmask, void 0, maskPos, !0);
837            var endResult = processCommandObject(result);
838            return endResult;
839        }
840        function positionCanMatchDefinition(pos, testDefinition, opts) {
841            for (var inputmask = this, maskset = this.maskset, valid = !1, tests = _validationTests.getTests.call(this, pos), tndx = 0; tndx < tests.length; tndx++) {
842                if (tests[tndx].match && (tests[tndx].match.nativeDef === testDefinition.match[opts.shiftPositions ? "def" : "nativeDef"] && (!opts.shiftPositions || !testDefinition.match.static) || tests[tndx].match.nativeDef === testDefinition.match.nativeDef || opts.regex && !tests[tndx].match.static && tests[tndx].match.fn.test(testDefinition.input))) {
843                    valid = !0;
844                    break;
845                }
846                if (tests[tndx].match && tests[tndx].match.def === testDefinition.match.nativeDef) {
847                    valid = void 0;
848                    break;
849                }
850            }
851            return !1 === valid && void 0 !== maskset.jitOffset[pos] && (valid = positionCanMatchDefinition.call(this, pos + maskset.jitOffset[pos], testDefinition, opts)),
852                valid;
853        }
854        function refreshFromBuffer(start, end, buffer) {
855            var inputmask = this, maskset = this.maskset, opts = this.opts, $ = this.dependencyLib, i, p, skipOptionalPartCharacter = opts.skipOptionalPartCharacter, bffr = this.isRTL ? buffer.slice().reverse() : buffer;

961            function isTemplateMatch(ndx, charCodes) {
962                for (var targetTemplate = _validationTests.getMaskTemplate.call(inputmask, !0, 0).slice(ndx, _positioning.seekNext.call(inputmask, ndx, !1, !1)).join("").replace(/'/g, ""), charCodeNdx = targetTemplate.indexOf(charCodes); 0 < charCodeNdx && " " === targetTemplate[charCodeNdx - 1];) charCodeNdx--;
963                var match = 0 === charCodeNdx && !_positioning.isMask.call(inputmask, ndx) && (_validationTests.getTest.call(inputmask, ndx).match.nativeDef === charCodes.charAt(0) || !0 === _validationTests.getTest.call(inputmask, ndx).match.static && _validationTests.getTest.call(inputmask, ndx).match.nativeDef === "'" + charCodes.charAt(0) || " " === _validationTests.getTest.call(inputmask, ndx).match.nativeDef && (_validationTests.getTest.call(inputmask, ndx + 1).match.nativeDef === charCodes.charAt(0) || !0 === _validationTests.getTest.call(inputmask, ndx + 1).match.static && _validationTests.getTest.call(inputmask, ndx + 1).match.nativeDef === "'" + charCodes.charAt(0)));
964                if (!match && 0 < charCodeNdx && !_positioning.isMask.call(inputmask, ndx, !1, !0)) {
965                    var nextPos = _positioning.seekNext.call(inputmask, ndx);
966                    inputmask.caretPos.begin < nextPos && (inputmask.caretPos = {
967                        begin: nextPos
968                    });
969                }
970                return match;
971            }
972            opts.skipOptionalPartCharacter = "", _positioning.resetMaskSet.call(inputmask),
973                maskset.tests = {}, initialNdx = opts.radixPoint ? _positioning.determineNewCaretPosition.call(inputmask, {
974                    begin: 0,
975                    end: 0
976                }, !1, !1 === opts.__financeInput ? "radixFocus" : void 0).begin : 0, maskset.p = initialNdx,
977                inputmask.caretPos = {
978                    begin: initialNdx
979                };
980            var staticMatches = [], prevCaretPos = inputmask.caretPos;
981            if (inputValue.forEach(function (charCode, ndx) {
982                if (void 0 !== charCode) {
983                    var keypress = new $.Event("_checkval");
984                    keypress.which = charCode.toString().charCodeAt(0), charCodes += charCode;
985                    var lvp = _positioning.getLastValidPosition.call(inputmask, void 0, !0);
986                    isTemplateMatch(initialNdx, charCodes) ? result = _eventhandlers.EventHandlers.keypressEvent.call(inputmask, keypress, !0, !1, strict, lvp + 1) : (result = _eventhandlers.EventHandlers.keypressEvent.call(inputmask, keypress, !0, !1, strict, inputmask.caretPos.begin),
987                        result && (initialNdx = inputmask.caretPos.begin + 1, charCodes = "")), result ? (void 0 !== result.pos && maskset.validPositions[result.pos] && !0 === maskset.validPositions[result.pos].match.static && void 0 === maskset.validPositions[result.pos].alternation && (staticMatches.push(result.pos),
988                            inputmask.isRTL || (result.forwardPosition = result.pos + 1)), writeBuffer.call(inputmask, void 0, _positioning.getBuffer.call(inputmask), result.forwardPosition, keypress, !1),
989                            inputmask.caretPos = {
990                                begin: result.forwardPosition,
991                                end: result.forwardPosition
992                            }, prevCaretPos = inputmask.caretPos) : void 0 === maskset.validPositions[ndx] && inputValue[ndx] === _validationTests.getPlaceholder.call(inputmask, ndx) && _positioning.isMask.call(inputmask, ndx, !0) ? inputmask.caretPos.begin++ : inputmask.caretPos = prevCaretPos;
993                }
994            }), 0 < staticMatches.length) {
995                var sndx, validPos, nextValid = _positioning.seekNext.call(inputmask, -1, void 0, !1);
996                if (!_validation.isComplete.call(inputmask, _positioning.getBuffer.call(inputmask)) && staticMatches.length <= nextValid || _validation.isComplete.call(inputmask, _positioning.getBuffer.call(inputmask)) && 0 < staticMatches.length && staticMatches.length !== nextValid && 0 === staticMatches[0]) for (var nextSndx = nextValid; void 0 !== (sndx = staticMatches.shift());) {
997                    var keypress = new $.Event("_checkval");
998                    if (validPos = maskset.validPositions[sndx], validPos.generatedInput = !0, keypress.which = validPos.input.charCodeAt(0),
999                        result = _eventhandlers.EventHandlers.keypressEvent.call(inputmask, keypress, !0, !1, strict, nextSndx),
1000                        result && void 0 !== result.pos && result.pos !== sndx && maskset.validPositions[result.pos] && !0 === maskset.validPositions[result.pos].match.static) staticMatches.push(result.pos); else if (!result) break;
1001                    nextSndx++;
1002                }
1003            }
1004            writeOut && writeBuffer.call(inputmask, input, _positioning.getBuffer.call(inputmask), result ? result.forwardPosition : inputmask.caretPos.begin, initiatingEvent || new $.Event("checkval"), initiatingEvent && "input" === initiatingEvent.type && inputmask.undoValue !== _positioning.getBuffer.call(inputmask).join("")),
1005                opts.skipOptionalPartCharacter = skipOptionalPartCharacter;
1006        }
1007        function HandleNativePlaceholder(npt, value) {
1008            var inputmask = npt ? npt.inputmask : this;
1009            if (_environment.ie) {
1010                if (npt.inputmask._valueGet() !== value && (npt.placeholder !== value || "" === npt.placeholder)) {
1011                    var buffer = _positioning.getBuffer.call(inputmask).slice(), nptValue = npt.inputmask._valueGet();
1012                    if (nptValue !== value) {
1013                        var lvp = _positioning.getLastValidPosition.call(inputmask);
1014                        -1 === lvp && nptValue === _positioning.getBufferTemplate.call(inputmask).join("") ? buffer = [] : -1 !== lvp && clearOptionalTail.call(inputmask, buffer),
1015                            writeBuffer(npt, buffer);
1016                    }
1017                }
1018            } else npt.placeholder !== value && (npt.placeholder = value, "" === npt.placeholder && npt.removeAttribute("placeholder"));
1019        }
1020        function unmaskedvalue(input) {
1021            var inputmask = input ? input.inputmask : this, opts = inputmask.opts, maskset = inputmask.maskset;
1022            if (input) {
1023                if (void 0 === input.inputmask) return input.value;
1024                input.inputmask && input.inputmask.refreshValue && applyInputValue(input, input.inputmask._valueGet(!0));
1025            }
1026            var umValue = [], vps = maskset.validPositions;
1027            for (var pndx in vps) vps[pndx] && vps[pndx].match && (1 != vps[pndx].match.static || Array.isArray(maskset.metadata) && !0 !== vps[pndx].generatedInput) && umValue.push(vps[pndx].input);
1028            var unmaskedValue = 0 === umValue.length ? "" : (inputmask.isRTL ? umValue.reverse() : umValue).join("");
1029            if ("function" == typeof opts.onUnMask) {
1030                var bufferValue = (inputmask.isRTL ? _positioning.getBuffer.call(inputmask).slice().reverse() : _positioning.getBuffer.call(inputmask)).join("");
1031                unmaskedValue = opts.onUnMask.call(inputmask, bufferValue, unmaskedValue, opts);
1032            }
1033            return unmaskedValue;
1034        }
1035        function writeBuffer(input, buffer, caretPos, event, triggerEvents) {
1036            var inputmask = input ? input.inputmask : this, opts = inputmask.opts, $ = inputmask.dependencyLib;
1037            if (event && "function" == typeof opts.onBeforeWrite) {
1038                var result = opts.onBeforeWrite.call(inputmask, event, buffer, caretPos, opts);
1039                if (result) {
1040                    if (result.refreshFromBuffer) {
1041                        var refresh = result.refreshFromBuffer;
1042                        _validation.refreshFromBuffer.call(inputmask, !0 === refresh ? refresh : refresh.start, refresh.end, result.buffer || buffer),
1043                            buffer = _positioning.getBuffer.call(inputmask, !0);
1044                    }
1045                    void 0 !== caretPos && (caretPos = void 0 !== result.caret ? result.caret : caretPos);
1046                }
1047            }
1048            if (void 0 !== input && (input.inputmask._valueSet(buffer.join("")), void 0 === caretPos || void 0 !== event && "blur" === event.type || _positioning.caret.call(inputmask, input, caretPos, void 0, void 0, void 0 !== event && "keydown" === event.type && (event.keyCode === _keycode.default.DELETE || event.keyCode === _keycode.default.BACKSPACE)),
1049                !0 === triggerEvents)) {
1050                var $input = $(input), nptVal = input.inputmask._valueGet();
1051                input.inputmask.skipInputEvent = !0, $input.trigger("input"), setTimeout(function () {
1052                    nptVal === _positioning.getBufferTemplate.call(inputmask).join("") ? $input.trigger("cleared") : !0 === _validation.isComplete.call(inputmask, buffer) && $input.trigger("complete");
1053                }, 0);
1054            }
1055        }
1056    }, function (module, exports, __webpack_require__) {
1057        "use strict";
1058        Object.defineProperty(exports, "__esModule", {
1059            value: !0
1060        }), exports.EventHandlers = void 0;
1061        var _positioning = __webpack_require__(1), _keycode = _interopRequireDefault(__webpack_require__(0)), _environment = __webpack_require__(7), _validation = __webpack_require__(4), _inputHandling = __webpack_require__(5), _validationTests = __webpack_require__(3);
1062        function _interopRequireDefault(obj) {
1063            return obj && obj.__esModule ? obj : {
1064                default: obj
1065            };
1066        }
1067        var EventHandlers = {
1068            keydownEvent: function keydownEvent(e) {
1069                var inputmask = this.inputmask, opts = inputmask.opts, $ = inputmask.dependencyLib, maskset = inputmask.maskset, input = this, $input = $(input), k = e.keyCode, pos = _positioning.caret.call(inputmask, input), kdResult = opts.onKeyDown.call(this, e, _positioning.getBuffer.call(inputmask), pos, opts);
1070                if (void 0 !== kdResult) return kdResult;
1071                if (k === _keycode.default.BACKSPACE || k === _keycode.default.DELETE || _environment.iphone && k === _keycode.default.BACKSPACE_SAFARI || e.ctrlKey && k === _keycode.default.X && !("oncut" in input)) e.preventDefault(),
1072                    _validation.handleRemove.call(inputmask, input, k, pos), (0, _inputHandling.writeBuffer)(input, _positioning.getBuffer.call(inputmask, !0), maskset.p, e, input.inputmask._valueGet() !== _positioning.getBuffer.call(inputmask).join("")); else if (k === _keycode.default.END || k === _keycode.default.PAGE_DOWN) {
1073                        e.preventDefault();
1074                        var caretPos = _positioning.seekNext.call(inputmask, _positioning.getLastValidPosition.call(inputmask));
1075                        _positioning.caret.call(inputmask, input, e.shiftKey ? pos.begin : caretPos, caretPos, !0);
1076                    } else k === _keycode.default.HOME && !e.shiftKey || k === _keycode.default.PAGE_UP ? (e.preventDefault(),
1077                        _positioning.caret.call(inputmask, input, 0, e.shiftKey ? pos.begin : 0, !0)) : (opts.undoOnEscape && k === _keycode.default.ESCAPE || 90 === k && e.ctrlKey) && !0 !== e.altKey ? ((0,
1078                            _inputHandling.checkVal)(input, !0, !1, inputmask.undoValue.split("")), $input.trigger("click")) : !0 === opts.tabThrough && k === _keycode.default.TAB ? !0 === e.shiftKey ? (pos.end = _positioning.seekPrevious.call(inputmask, pos.end, !0),
1079                                !0 === _validationTests.getTest.call(inputmask, pos.end - 1).match.static && pos.end-- ,
1080                                pos.begin = _positioning.seekPrevious.call(inputmask, pos.end, !0), 0 <= pos.begin && 0 < pos.end && (e.preventDefault(),
1081                                    _positioning.caret.call(inputmask, input, pos.begin, pos.end))) : (pos.begin = _positioning.seekNext.call(inputmask, pos.begin, !0),
1082                                        pos.end = _positioning.seekNext.call(inputmask, pos.begin, !0), pos.end < maskset.maskLength && pos.end-- ,
1083                                        pos.begin <= maskset.maskLength && (e.preventDefault(), _positioning.caret.call(inputmask, input, pos.begin, pos.end))) : e.shiftKey || opts.insertModeVisual && !1 === opts.insertMode && (k === _keycode.default.RIGHT ? setTimeout(function () {
1084                                            var caretPos = _positioning.caret.call(inputmask, input);
1085                                            _positioning.caret.call(inputmask, input, caretPos.begin);
1086                                        }, 0) : k === _keycode.default.LEFT && setTimeout(function () {
1087                                            var caretPos_begin = _positioning.translatePosition.call(inputmask, input.inputmask.caretPos.begin), caretPos_end = _positioning.translatePosition.call(inputmask, input.inputmask.caretPos.end);
1088                                            inputmask.isRTL ? _positioning.caret.call(inputmask, input, caretPos_begin + (caretPos_begin === maskset.maskLength ? 0 : 1)) : _positioning.caret.call(inputmask, input, caretPos_begin - (0 === caretPos_begin ? 0 : 1));
1089                                        }, 0));
1090                inputmask.ignorable = opts.ignorables.includes(k);
1091            },
1092            keypressEvent: function keypressEvent(e, checkval, writeOut, strict, ndx) {
1093                var inputmask = this.inputmask || this, opts = inputmask.opts, $ = inputmask.dependencyLib, maskset = inputmask.maskset, input = inputmask.el, $input = $(input), k = e.which || e.charCode || e.keyCode;
1094                if (!(!0 === checkval || e.ctrlKey && e.altKey) && (e.ctrlKey || e.metaKey || inputmask.ignorable)) return k === _keycode.default.ENTER && inputmask.undoValue !== _positioning.getBuffer.call(inputmask).join("") && (inputmask.undoValue = _positioning.getBuffer.call(inputmask).join(""),
1095                    setTimeout(function () {
1096                        $input.trigger("change");
1097                    }, 0)), inputmask.skipInputEvent = !0, !0;
1098                if (k) {
1099                    44 !== k && 46 !== k || 3 !== e.location || "" === opts.radixPoint || (k = opts.radixPoint.charCodeAt(0));
1100                    var pos = checkval ? {
1101                        begin: ndx,
1102                        end: ndx
1103                    } : _positioning.caret.call(inputmask, input), forwardPosition, c = String.fromCharCode(k);
1104                    maskset.writeOutBuffer = !0;
1105                    var valResult = _validation.isValid.call(inputmask, pos, c, strict, void 0, void 0, void 0, checkval);
1106                    if (!1 !== valResult && (_positioning.resetMaskSet.call(inputmask, !0), forwardPosition = void 0 !== valResult.caret ? valResult.caret : _positioning.seekNext.call(inputmask, valResult.pos.begin ? valResult.pos.begin : valResult.pos),
1107                        maskset.p = forwardPosition), forwardPosition = opts.numericInput && void 0 === valResult.caret ? _positioning.seekPrevious.call(inputmask, forwardPosition) : forwardPosition,
1108                        !1 !== writeOut && (setTimeout(function () {
1109                            opts.onKeyValidation.call(input, k, valResult);
1110                        }, 0), maskset.writeOutBuffer && !1 !== valResult)) {
1111                        var buffer = _positioning.getBuffer.call(inputmask);
1112                        (0, _inputHandling.writeBuffer)(input, buffer, forwardPosition, e, !0 !== checkval);
1113                    }
1114                    if (e.preventDefault(), checkval) return !1 !== valResult && (valResult.forwardPosition = forwardPosition),
1115                        valResult;
1116                }
1117            },
1118            keyupEvent: function keyupEvent(e) {
1119                var inputmask = this.inputmask;
1120                !inputmask.isComposing || e.keyCode !== _keycode.default.KEY_229 && e.keyCode !== _keycode.default.ENTER || inputmask.$el.trigger("input");
1121            },
1122            pasteEvent: function pasteEvent(e) {
1123                var inputmask = this.inputmask, opts = inputmask.opts, input = this, inputValue = inputmask._valueGet(!0), caretPos = _positioning.caret.call(inputmask, this), tempValue;
1124                inputmask.isRTL && (tempValue = caretPos.end, caretPos.end = caretPos.begin, caretPos.begin = tempValue);
1125                var valueBeforeCaret = inputValue.substr(0, caretPos.begin), valueAfterCaret = inputValue.substr(caretPos.end, inputValue.length);
1126                if (valueBeforeCaret == (inputmask.isRTL ? _positioning.getBufferTemplate.call(inputmask).slice().reverse() : _positioning.getBufferTemplate.call(inputmask)).slice(0, caretPos.begin).join("") && (valueBeforeCaret = ""),
1127                    valueAfterCaret == (inputmask.isRTL ? _positioning.getBufferTemplate.call(inputmask).slice().reverse() : _positioning.getBufferTemplate.call(inputmask)).slice(caretPos.end).join("") && (valueAfterCaret = ""),
1128                    window.clipboardData && window.clipboardData.getData) inputValue = valueBeforeCaret + window.clipboardData.getData("Text") + valueAfterCaret; else {
1129                    if (!e.clipboardData || !e.clipboardData.getData) return !0;
1130                    inputValue = valueBeforeCaret + e.clipboardData.getData("text/plain") + valueAfterCaret;
1131                }
1132                var pasteValue = inputValue;
1133                if ("function" == typeof opts.onBeforePaste) {
1134                    if (pasteValue = opts.onBeforePaste.call(inputmask, inputValue, opts), !1 === pasteValue) return e.preventDefault();
1135                    pasteValue = pasteValue || inputValue;
1136                }
1137                return (0, _inputHandling.checkVal)(this, !0, !1, pasteValue.toString().split(""), e),
1138                    e.preventDefault();
1139            },
1140            inputFallBackEvent: function inputFallBackEvent(e) {
1141                var inputmask = this.inputmask, opts = inputmask.opts, $ = inputmask.dependencyLib;
1142                function ieMobileHandler(input, inputValue, caretPos) {
1143                    if (_environment.iemobile) {
1144                        var inputChar = inputValue.replace(_positioning.getBuffer.call(inputmask).join(""), "");
1145                        if (1 === inputChar.length) {
1146                            var iv = inputValue.split("");
1147                            iv.splice(caretPos.begin, 0, inputChar), inputValue = iv.join("");
1148                        }
1149                    }
1150                    return inputValue;
1151                }
1152                function analyseChanges(inputValue, buffer, caretPos) {
1153                    for (var frontPart = inputValue.substr(0, caretPos.begin).split(""), backPart = inputValue.substr(caretPos.begin).split(""), frontBufferPart = buffer.substr(0, caretPos.begin).split(""), backBufferPart = buffer.substr(caretPos.begin).split(""), fpl = frontPart.length >= frontBufferPart.length ? frontPart.length : frontBufferPart.length, bpl = backPart.length >= backBufferPart.length ? backPart.length : backBufferPart.length, bl, i, action = "", data = [], marker = "~", placeholder; frontPart.length < fpl;

1326, function (module, exports) {
1327        module.exports = __WEBPACK_EXTERNAL_MODULE__10__;
1328    }, function (module, exports, __webpack_require__) {
1329        "use strict";
1330        Object.defineProperty(exports, "__esModule", {
1331            value: !0
1332        }), exports.EventRuler = void 0;
1333        var _inputmask = _interopRequireDefault(__webpack_require__(2)), _keycode = _interopRequireDefault(__webpack_require__(0)), _positioning = __webpack_require__(1), _inputHandling = __webpack_require__(5);
1334        function _interopRequireDefault(obj) {
1335            return obj && obj.__esModule ? obj : {
1336                default: obj
1337            };
1338        }
1339        var EventRuler = {
1340            on: function on(input, eventName, eventHandler) {
1341                var $ = input.inputmask.dependencyLib, ev = function ev(e) {
1342                    e.originalEvent && (e = e.originalEvent || e, arguments[0] = e);
1343                    var that = this, args, inputmask = that.inputmask, opts = inputmask ? inputmask.opts : void 0;
1344                    if (void 0 === inputmask && "FORM" !== this.nodeName) {
1345                        var imOpts = $.data(that, "_inputmask_opts");
1346                        $(that).off(), imOpts && new _inputmask.default(imOpts).mask(that);
1347                    } else {
1348                        if (["submit", "reset", "setvalue"].includes(e.type) || "FORM" === this.nodeName || !(that.disabled || that.readOnly && !("keydown" === e.type && e.ctrlKey && 67 === e.keyCode || !1 === opts.tabThrough && e.keyCode === _keycode.default.TAB))) {
1349                            switch (e.type) {
1350                                case "input":
1351                                    if (!0 === inputmask.skipInputEvent || e.inputType && "insertCompositionText" === e.inputType) return inputmask.skipInputEvent = !1,
1352                                        e.preventDefault();
1353                                    break;
1354
1355                                case "keydown":
1356                                    inputmask.skipKeyPressEvent = !1, inputmask.skipInputEvent = inputmask.isComposing = e.keyCode === _keycode.default.KEY_229;
1357                                    break;
1358
1359                                case "keyup":
1360                                case "compositionend":
1361                                    inputmask.isComposing && (inputmask.skipInputEvent = !1);
1362                                    break;
1363
1364                                case "keypress":
1365                                    if (!0 === inputmask.skipKeyPressEvent) return e.preventDefault();
1366                                    inputmask.skipKeyPressEvent = !0;
1367                                    break;
1368
1369                                case "click":
1370                                case "focus":
1371                                    return inputmask.validationEvent ? (inputmask.validationEvent = !1, input.blur(),
1372                                        (0, _inputHandling.HandleNativePlaceholder)(input, (inputmask.isRTL ? _positioning.getBufferTemplate.call(inputmask).slice().reverse() : _positioning.getBufferTemplate.call(inputmask)).join("")),
1373                                        setTimeout(function () {
1374                                            input.focus();
1375                                        }, 3e3)) : (args = arguments, setTimeout(function () {
1376                                            input.inputmask && eventHandler.apply(that, args);
1377                                        }, 0)), !1;
1378                            }
1379                            var returnVal = eventHandler.apply(that, arguments);
1380                            return !1 === returnVal && (e.preventDefault(), e.stopPropagation()), returnVal;
1381                        }
1382                        e.preventDefault();
1383                    }
1384                };
1385                ["submit", "reset"].includes(eventName) ? (ev = ev.bind(input), null !== input.form && $(input.form).on(eventName, ev)) : $(input).on(eventName, ev),
1386                    input.inputmask.events[eventName] = input.inputmask.events[eventName] || [], input.inputmask.events[eventName].push(ev);
1387            },
1388            off: function off(input, event) {
1389                if (input.inputmask && input.inputmask.events) {
1390                    var $ = input.inputmask.dependencyLib, events = input.inputmask.events;
1391                    for (var eventName in event && (events = [], events[event] = input.inputmask.events[event]),
1392                        events) {
1393                        for (var evArr = events[eventName]; 0 < evArr.length;) {
1394                            var ev = evArr.pop();
1395                            ["submit", "reset"].includes(eventName) ? null !== input.form && $(input.form).off(eventName, ev) : $(input).off(eventName, ev);
1396                        }
1397                        delete input.inputmask.events[eventName];
1398                    }
1399                }
1400            }
1401        };
1402        exports.EventRuler = EventRuler;
1403    }, function (module, exports, __webpack_require__) {
1404        "use strict";
1405        Object.defineProperty(exports, "__esModule", {
1406            value: !0
1407        }), exports.default = void 0;
1408        var _jquery = _interopRequireDefault(__webpack_require__(10));
1409        function _interopRequireDefault(obj) {
1410            return obj && obj.__esModule ? obj : {
1411                default: obj
1412            };
1413        }
1414        if (void 0 === _jquery.default) throw "jQuery not loaded!";
1415        var _default = _jquery.default;
1416        exports.default = _default;
1417    }, function (module, exports, __webpack_require__) {
1418        "use strict";
1419        Object.defineProperty(exports, "__esModule", {
1420            value: !0
1421        }), exports.default = _default;
1422        var escapeRegexRegex = new RegExp("(\\" + ["/", ".", "*", "+", "?", "|", "(", ")", "[", "]", "{", "}", "\\", "$", "^"].join("|\\") + ")", "gim");
1423        function _default(str) {
1424            return str.replace(escapeRegexRegex, "\\$1");
1425        }
1426    }, function (module, exports, __webpack_require__) {
1427        "use strict";
1428        Object.defineProperty(exports, "__esModule", {
1429            value: !0
1430        }), exports.default = void 0, __webpack_require__(15), __webpack_require__(23),
1431            __webpack_require__(24), __webpack_require__(25);
1432        var _inputmask2 = _interopRequireDefault(__webpack_require__(2));
1433        function _interopRequireDefault(obj) {
1434            return obj && obj.__esModule ? obj : {
1435                default: obj
1436            };
1437        }
1438        var _default = _inputmask2.default;
1439        exports.default = _default;
1440    }, function (module, exports, __webpack_require__) {
1441        "use strict";
1442        var _inputmask = _interopRequireDefault(__webpack_require__(2)), _positioning = __webpack_require__(1), _validationTests = __webpack_require__(3);
1443        function _interopRequireDefault(obj) {
1444            return obj && obj.__esModule ? obj : {
1445                default: obj
1446            };
1447        }
1448        _inputmask.default.extendDefinitions({
1449            A: {
1450                validator: "[A-Za-z\u0410-\u044f\u0401\u0451\xc0-\xff\xb5]",
1451                casing: "upper"
1452            },
1453            "&": {
1454                validator: "[0-9A-Za-z\u0410-\u044f\u0401\u0451\xc0-\xff\xb5]",
1455                casing: "upper"
1456            },
1457            "#": {
1458                validator: "[0-9A-Fa-f]",
1459                casing: "upper"
1460            }
1461        });
1462        var ipValidatorRegex = new RegExp("25[0-5]|2[0-4][0-9]|[01][0-9][0-9]");
1463        function ipValidator(chrs, maskset, pos, strict, opts) {

1670opts.showMaskOnFocus = opts.showMaskOnFocus && -1 === ["cc-number", "cc-exp"].indexOf(el.autocomplete),
1671                            _environment.iphone && (opts.insertModeVisual = !1), _eventruler.EventRuler.on(el, "submit", _eventhandlers.EventHandlers.submitEvent),
1672                            _eventruler.EventRuler.on(el, "reset", _eventhandlers.EventHandlers.resetEvent),
1673                            _eventruler.EventRuler.on(el, "blur", _eventhandlers.EventHandlers.blurEvent), _eventruler.EventRuler.on(el, "focus", _eventhandlers.EventHandlers.focusEvent),
1674                            _eventruler.EventRuler.on(el, "invalid", _eventhandlers.EventHandlers.invalidEvent),
1675                            _eventruler.EventRuler.on(el, "click", _eventhandlers.EventHandlers.clickEvent),
1676                            _eventruler.EventRuler.on(el, "mouseleave", _eventhandlers.EventHandlers.mouseleaveEvent),
1677                            _eventruler.EventRuler.on(el, "mouseenter", _eventhandlers.EventHandlers.mouseenterEvent),
1678                            _eventruler.EventRuler.on(el, "paste", _eventhandlers.EventHandlers.pasteEvent),
1679                            _eventruler.EventRuler.on(el, "cut", _eventhandlers.EventHandlers.cutEvent), _eventruler.EventRuler.on(el, "complete", opts.oncomplete),
1680                            _eventruler.EventRuler.on(el, "incomplete", opts.onincomplete), _eventruler.EventRuler.on(el, "cleared", opts.oncleared),
1681                            !0 !== opts.inputEventOnly && (_eventruler.EventRuler.on(el, "keydown", _eventhandlers.EventHandlers.keydownEvent),
1682                                _eventruler.EventRuler.on(el, "keypress", _eventhandlers.EventHandlers.keypressEvent),
1683                                _eventruler.EventRuler.on(el, "keyup", _eventhandlers.EventHandlers.keyupEvent)),
1684                            (_environment.mobile || opts.inputEventOnly) && el.removeAttribute("maxLength"),
1685                            _eventruler.EventRuler.on(el, "input", _eventhandlers.EventHandlers.inputFallBackEvent),
1686                            _eventruler.EventRuler.on(el, "compositionend", _eventhandlers.EventHandlers.compositionendEvent)),
1687                    _eventruler.EventRuler.on(el, "setvalue", _eventhandlers.EventHandlers.setValueEvent),
1688                    inputmask.undoValue = _positioning.getBufferTemplate.call(inputmask).join("");
1689                var activeElement = (el.inputmask.shadowRoot || document).activeElement;
1690                if ("" !== el.inputmask._valueGet(!0) || !1 === opts.clearMaskOnLostFocus || activeElement === el) {
1691                    (0, _inputHandling.applyInputValue)(el, el.inputmask._valueGet(!0), opts);
1692                    var buffer = _positioning.getBuffer.call(inputmask).slice();
1693                    !1 === _validation.isComplete.call(inputmask, buffer) && opts.clearIncomplete && _positioning.resetMaskSet.call(inputmask),
1694                        opts.clearMaskOnLostFocus && activeElement !== el && (-1 === _positioning.getLastValidPosition.call(inputmask) ? buffer = [] : _inputHandling.clearOptionalTail.call(inputmask, buffer)),
1695                        (!1 === opts.clearMaskOnLostFocus || opts.showMaskOnFocus && activeElement === el || "" !== el.inputmask._valueGet(!0)) && (0,
1696                            _inputHandling.writeBuffer)(el, buffer), activeElement === el && _positioning.caret.call(inputmask, el, _positioning.seekNext.call(inputmask, _positioning.getLastValidPosition.call(inputmask)));
1697                }
1698            }
1699        }
1700    }, function (module, exports, __webpack_require__) {
1701        "use strict";
1702        Object.defineProperty(exports, "__esModule", {
1703            value: !0
1704        }), exports.generateMaskSet = generateMaskSet, exports.analyseMask = analyseMask;
1705        var _inputmask = _interopRequireDefault(__webpack_require__(12)), _masktoken = _interopRequireDefault(__webpack_require__(20));
1706        function _interopRequireDefault(obj) {
1707            return obj && obj.__esModule ? obj : {
1708                default: obj
1709            };
1710        }
1711        function generateMaskSet(opts, nocache) {
1712            var ms;
1713            function generateMask(mask, metadata, opts) {
1714                var regexMask = !1, masksetDefinition, maskdefKey;
1715                if (null !== mask && "" !== mask || (regexMask = null !== opts.regex, mask = regexMask ? (mask = opts.regex,
1716                    mask.replace(/^(\^)(.*)(\$)$/, "$2")) : (regexMask = !0, ".*")), 1 === mask.length && !1 === opts.greedy && 0 !== opts.repeat && (opts.placeholder = ""),
1717                    0 < opts.repeat || "*" === opts.repeat || "+" === opts.repeat) {
1718                    var repeatStart = "*" === opts.repeat ? 0 : "+" === opts.repeat ? 1 : opts.repeat;
1719                    mask = opts.groupmarker[0] + mask + opts.groupmarker[1] + opts.quantifiermarker[0] + repeatStart + "," + opts.repeat + opts.quantifiermarker[1];
1720                }
1721                return maskdefKey = regexMask ? "regex_" + opts.regex : opts.numericInput ? mask.split("").reverse().join("") : mask,
1722                    !1 !== opts.keepStatic && (maskdefKey = "ks_" + maskdefKey), void 0 === Inputmask.prototype.masksCache[maskdefKey] || !0 === nocache ? (masksetDefinition = {
1723                        mask: mask,
1724                        maskToken: Inputmask.prototype.analyseMask(mask, regexMask, opts),
1725                        validPositions: {},
1726                        _buffer: void 0,
1727                        buffer: void 0,
1728                        tests: {},
1729                        excludes: {},
1730                        metadata: metadata,
1731                        maskLength: void 0,
1732                        jitOffset: {}
1733                    }, !0 !== nocache && (Inputmask.prototype.masksCache[maskdefKey] = masksetDefinition,
1734                        masksetDefinition = _inputmask.default.extend(!0, {}, Inputmask.prototype.masksCache[maskdefKey]))) : masksetDefinition = _inputmask.default.extend(!0, {}, Inputmask.prototype.masksCache[maskdefKey]),
1735                    masksetDefinition;
1736            }
1737            if ("function" == typeof opts.mask && (opts.mask = opts.mask(opts)), Array.isArray(opts.mask)) {
1738                if (1 < opts.mask.length) {
1739                    null === opts.keepStatic && (opts.keepStatic = !0);
1740                    var altMask = opts.groupmarker[0];
1741                    return (opts.isRTL ? opts.mask.reverse() : opts.mask).forEach(function (msk) {
1742                        1 < altMask.length && (altMask += opts.groupmarker[1] + opts.alternatormarker + opts.groupmarker[0]),
1743                            void 0 !== msk.mask && "function" != typeof msk.mask ? altMask += msk.mask : altMask += msk;
1744                    }), altMask += opts.groupmarker[1], generateMask(altMask, opts.mask, opts);
1745                }
1746                opts.mask = opts.mask.pop();
1747            }
1748            return null === opts.keepStatic && (opts.keepStatic = !1), ms = opts.mask && void 0 !== opts.mask.mask && "function" != typeof opts.mask.mask ? generateMask(opts.mask.mask, opts.mask, opts) : generateMask(opts.mask, opts.mask, opts),
1749                ms;
1750        }
1751        function analyseMask(mask, regexMask, opts) {
1752            var tokenizer = /(?:[?*+]|\{[0-9+*]+(?:,[0-9+*]*)?(?:\|[0-9+*]*)?\})|[^.?*+^${[]()|\\]+|./g, regexTokenizer = /\[\^?]?(?:[^\\\]]+|\\[\S\s]?)*]?|\\(?:0(?:[0-3][0-7]{0,2}|[4-7][0-7]?)?|[1-9][0-9]*|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|c[A-Za-z]|[\S\s]?)|\((?:\?[:=!]?)?|(?:[?*+]|\{[0-9]+(?:,[0-9]*)?\})\??|[^.?*+^${[()|\\]+|./g, escaped = !1, currentToken = new _masktoken.default(), match, m, openenings = [], maskTokens = [], openingToken, currentOpeningToken, alternator, lastMatch, closeRegexGroup = !1;
1753            function insertTestDefinition(mtoken, element, position) {
1754                position = void 0 !== position ? position : mtoken.matches.length;
1755                var prevMatch = mtoken.matches[position - 1];
1756                if (regexMask) 0 === element.indexOf("[") || escaped && /\\d|\\s|\\w]/i.test(element) || "." === element ? mtoken.matches.splice(position++, 0, {
1757                    fn: new RegExp(element, opts.casing ? "i" : ""),
1758                    static: !1,
1759                    optionality: !1,
1760                    newBlockMarker: void 0 === prevMatch ? "master" : prevMatch.def !== element,
1761                    casing: null,
1762                    def: element,
1763                    placeholder: void 0,
1764                    nativeDef: element
1765                }) : (escaped && (element = element[element.length - 1]), element.split("").forEach(function (lmnt, ndx) {
1766                    prevMatch = mtoken.matches[position - 1], mtoken.matches.splice(position++, 0, {
1767                        fn: /[a-z]/i.test(opts.staticDefinitionSymbol || lmnt) ? new RegExp("[" + (opts.staticDefinitionSymbol || lmnt) + "]", opts.casing ? "i" : "") : null,
1768                        static: !0,
1769                        optionality: !1,
1770                        newBlockMarker: void 0 === prevMatch ? "master" : prevMatch.def !== lmnt && !0 !== prevMatch.static,
1771                        casing: null,
1772                        def: opts.staticDefinitionSymbol || lmnt,
1773                        placeholder: void 0 !== opts.staticDefinitionSymbol ? lmnt : void 0,
1774                        nativeDef: (escaped ? "'" : "") + lmnt
1775                    });
1776                })), escaped = !1; else {
1777                    var maskdef = opts.definitions && opts.definitions[element] || opts.usePrototypeDefinitions && Inputmask.prototype.definitions[element];
1778                    maskdef && !escaped ? mtoken.matches.splice(position++, 0, {
1779                        fn: maskdef.validator ? "string" == typeof maskdef.validator ? new RegExp(maskdef.validator, opts.casing ? "i" : "") : new function () {
1780                            this.test = maskdef.validator;
1781                        }() : new RegExp("."),
1782                        static: maskdef.static || !1,
1783                        optionality: !1,
1784                        newBlockMarker: void 0 === prevMatch ? "master" : prevMatch.def !== (maskdef.definitionSymbol || element),
1785                        casing: maskdef.casing,
1786                        def: maskdef.definitionSymbol || element,
1787                        placeholder: maskdef.placeholder,
1788                        nativeDef: element,
1789                        generated: maskdef.generated
1790                    }) : (mtoken.matches.splice(position++, 0, {
1791                        fn: /[a-z]/i.test(opts.staticDefinitionSymbol || element) ? new RegExp("[" + (opts.staticDefinitionSymbol || element) + "]", opts.casing ? "i" : "") : null,
1792                        static: !0,
1793                        optionality: !1,
1794                        newBlockMarker: void 0 === prevMatch ? "master" : prevMatch.def !== element && !0 !== prevMatch.static,
1795                        casing: null,
1796                        def: opts.staticDefinitionSymbol || element,
1797                        placeholder: void 0 !== opts.staticDefinitionSymbol ? element : void 0,
1798                        nativeDef: (escaped ? "'" : "") + element
1799                    }), escaped = !1);
1800                }
1801            }
1802            function verifyGroupMarker(maskToken) {
1803                maskToken && maskToken.matches && maskToken.matches.forEach(function (token, ndx) {
1804                    var nextToken = maskToken.matches[ndx + 1];
1805                    (void 0 === nextToken || void 0 === nextToken.matches || !1 === nextToken.isQuantifier) && token && token.isGroup && (token.isGroup = !1,
1806                        regexMask || (insertTestDefinition(token, opts.groupmarker[0], 0), !0 !== token.openGroup && insertTestDefinition(token, opts.groupmarker[1]))),
1807                        verifyGroupMarker(token);
1808                });
1809            }
1810            function defaultCase() {
1811                if (0 < openenings.length) {
1812                    if (currentOpeningToken = openenings[openenings.length - 1], insertTestDefinition(currentOpeningToken, m),
1813                        currentOpeningToken.isAlternator) {
1814                        alternator = openenings.pop();
1815                        for (var mndx = 0; mndx < alternator.matches.length; mndx++) alternator.matches[mndx].isGroup && (alternator.matches[mndx].isGroup = !1);
1816                        0 < openenings.length ? (currentOpeningToken = openenings[openenings.length - 1],
1817                            currentOpeningToken.matches.push(alternator)) : currentToken.matches.push(alternator);
1818                    }
1819                } else insertTestDefinition(currentToken, m);
1820            }
1821            function reverseTokens(maskToken) {
1822                function reverseStatic(st) {
1823                    return st === opts.optionalmarker[0] ? st = opts.optionalmarker[1] : st === opts.optionalmarker[1] ? st = opts.optionalmarker[0] : st === opts.groupmarker[0] ? st = opts.groupmarker[1] : st === opts.groupmarker[1] && (st = opts.groupmarker[0]),
1824                        st;
1825                }
1826                for (var match in maskToken.matches = maskToken.matches.reverse(), maskToken.matches) if (Object.prototype.hasOwnProperty.call(maskToken.matches, match)) {
1827                    var intMatch = parseInt(match);
1828                    if (maskToken.matches[match].isQuantifier && maskToken.matches[intMatch + 1] && maskToken.matches[intMatch + 1].isGroup) {
1829                        var qt = maskToken.matches[match];
1830                        maskToken.matches.splice(match, 1), maskToken.matches.splice(intMatch + 1, 0, qt);
1831                    }
1832                    void 0 !== maskToken.matches[match].matches ? maskToken.matches[match] = reverseTokens(maskToken.matches[match]) : maskToken.matches[match] = reverseStatic(maskToken.matches[match]);
1833                }
1834                return maskToken;
1835            }
1836            function groupify(matches) {
1837                var groupToken = new _masktoken.default(!0);
1838                return groupToken.openGroup = !1, groupToken.matches = matches, groupToken;
1839            }
1840            function closeGroup() {
1841                if (openingToken = openenings.pop(), openingToken.openGroup = !1, void 0 !== openingToken) if (0 < openenings.length) {
1842                    if (currentOpeningToken = openenings[openenings.length - 1], currentOpeningToken.matches.push(openingToken),
1843                        currentOpeningToken.isAlternator) {
1844                        alternator = openenings.pop();
1845                        for (var mndx = 0; mndx < alternator.matches.length; mndx++) alternator.matches[mndx].isGroup = !1,
1846                            alternator.matches[mndx].alternatorGroup = !1;
1847                        0 < openenings.length ? (currentOpeningToken = openenings[openenings.length - 1],
1848                            currentOpeningToken.matches.push(alternator)) : currentToken.matches.push(alternator);
1849                    }
1850                } else currentToken.matches.push(openingToken); else defaultCase();
1851            }
1852            function groupQuantifier(matches) {
1853                var lastMatch = matches.pop();
1854                return lastMatch.isQuantifier && (lastMatch = groupify([matches.pop(), lastMatch])),
1855                    lastMatch;
1856            }
1857            for (regexMask && (opts.optionalmarker[0] = void 0, opts.optionalmarker[1] = void 0); match = regexMask ? regexTokenizer.exec(mask) : tokenizer.exec(mask);) {
1858                if (m = match[0], regexMask) switch (m.charAt(0)) {
1859                    case "?":
1860                        m = "{0,1}";
1861                        break;
1862
1863                    case "+":
1864                    case "*":
1865                        m = "{" + m + "}";
1866                        break;
1867
1868                    case "|":
1869                        if (0 === openenings.length) {
1870                            var altRegexGroup = groupify(currentToken.matches);
1871                            altRegexGroup.openGroup = !0, openenings.push(altRegexGroup), currentToken.matches = [],
1872                                closeRegexGroup = !0;
1873                        }
1874                        break;
1875                }
1876                if (escaped) defaultCase(); else switch (m.charAt(0)) {
1877                    case "$":
1878                    case "^":
1879                        regexMask || defaultCase();
1880                        break;
1881
1882                    case "(?=":
1883                        openenings.push(new _masktoken.default(!0));
1884                        break;
1885
1886                    case "(?!":
1887                        openenings.push(new _masktoken.default(!0));
1888                        break;
1889
1890                    case "(?<=":
1891                        openenings.push(new _masktoken.default(!0));
1892                        break;
1893
1894                    case "(?<!":
1895                        openenings.push(new _masktoken.default(!0));
1896                        break;
1897
1898                    case opts.escapeChar:
1899                        escaped = !0, regexMask && defaultCase();
1900                        break;
1901
1902                    case opts.optionalmarker[1]:
1903                    case opts.groupmarker[1]:
1904                        closeGroup();
1905                        break;
1906
1907                    case opts.optionalmarker[0]:
1908                        openenings.push(new _masktoken.default(!1, !0));
1909                        break;
1910
1911                    case opts.groupmarker[0]:
1912                        openenings.push(new _masktoken.default(!0));
1913                        break;
1914
1915                    case opts.quantifiermarker[0]:
1916                        var quantifier = new _masktoken.default(!1, !1, !0);
1917                        m = m.replace(/[{}]/g, "");
1918                        var mqj = m.split("|"), mq = mqj[0].split(","), mq0 = isNaN(mq[0]) ? mq[0] : parseInt(mq[0]), mq1 = 1 === mq.length ? mq0 : isNaN(mq[1]) ? mq[1] : parseInt(mq[1]);
1919                        "*" !== mq0 && "+" !== mq0 || (mq0 = "*" === mq1 ? 0 : 1), quantifier.quantifier = {
1920                            min: mq0,
1921                            max: mq1,
1922                            jit: mqj[1]
1923                        };
1924                        var matches = 0 < openenings.length ? openenings[openenings.length - 1].matches : currentToken.matches;
1925                        if (match = matches.pop(), match.isAlternator) {
1926                            matches.push(match), matches = match.matches;
1927                            var groupToken = new _masktoken.default(!0), tmpMatch = matches.pop();
1928                            matches.push(groupToken), matches = groupToken.matches, match = tmpMatch;
1929                        }
1930                        match.isGroup || (match = groupify([match])), matches.push(match), matches.push(quantifier);
1931                        break;
1932
1933                    case opts.alternatormarker:
1934                        if (0 < openenings.length) {
1935                            currentOpeningToken = openenings[openenings.length - 1];
1936                            var subToken = currentOpeningToken.matches[currentOpeningToken.matches.length - 1];
1937                            lastMatch = currentOpeningToken.openGroup && (void 0 === subToken.matches || !1 === subToken.isGroup && !1 === subToken.isAlternator) ? openenings.pop() : groupQuantifier(currentOpeningToken.matches);
1938                        } else lastMatch = groupQuantifier(currentToken.matches);
1939                        if (lastMatch.isAlternator) openenings.push(lastMatch); else if (lastMatch.alternatorGroup ? (alternator = openenings.pop(),
1940                            lastMatch.alternatorGroup = !1) : alternator = new _masktoken.default(!1, !1, !1, !0),
1941                            alternator.matches.push(lastMatch), openenings.push(alternator), lastMatch.openGroup) {
1942                            lastMatch.openGroup = !1;
1943                            var alternatorGroup = new _masktoken.default(!0);
1944                            alternatorGroup.alternatorGroup = !0, openenings.push(alternatorGroup);
1945                        }
1946                        break;
1947
1948                    default:
1949                        defaultCase();
1950                }
1951            }
1952            for (closeRegexGroup && closeGroup(); 0 < openenings.length;) openingToken = openenings.pop(),
1953                currentToken.matches.push(openingToken);
1954            return 0 < currentToken.matches.length && (verifyGroupMarker(currentToken), maskTokens.push(currentToken)),
1955                (opts.numericInput || opts.isRTL) && reverseTokens(maskTokens[0]), maskTokens;
1956        }
1957    }, function (module, exports, __webpack_require__) {
1958        "use strict";
1959        function _default(isGroup, isOptional, isQuantifier, isAlternator) {
1960            this.matches = [], this.openGroup = isGroup || !1, this.alternatorGroup = !1, this.isGroup = isGroup || !1,
1961                this.isOptional = isOptional || !1, this.isQuantifier = is

2069        var $ = _inputmask.default.dependencyLib, currentYear = new Date().getFullYear(), formatCode = {
2070            d: ["[1-9]|[12][0-9]|3[01]", Date.prototype.setDate, "day", Date.prototype.getDate],
2071            dd: ["0[1-9]|[12][0-9]|3[01]", Date.prototype.setDate, "day", function () {
2072                return pad(Date.prototype.getDate.call(this), 2);
2073            }],
2074            ddd: [""],
2075            dddd: [""],
2076            m: ["[1-9]|1[012]", Date.prototype.setMonth, "month", function () {
2077                return Date.prototype.getMonth.call(this) + 1;
2078            }],
2079            mm: ["0[1-9]|1[012]", Date.prototype.setMonth, "month", function () {
2080                return pad(Date.prototype.getMonth.call(this) + 1, 2);
2081            }],
2082            mmm: [""],
2083            mmmm: [""],
2084            yy: ["[0-9]{2}", Date.prototype.setFullYear, "year", function () {
2085                return pad(Date.prototype.getFullYear.call(this), 2);
2086            }],
2087            yyyy: ["[0-9]{4}", Date.prototype.setFullYear, "year", function () {
2088                return pad(Date.prototype.getFullYear.call(this), 4);
2089            }],
2090            h: ["[1-9]|1[0-2]", Date.prototype.setHours, "hours", Date.prototype.getHours],
2091            hh: ["0[1-9]|1[0-2]", Date.prototype.setHours, "hours", function () {
2092                return pad(Date.prototype.getHours.call(this), 2);
2093            }],
2094            hx: [function (x) {
2095                return "[0-9]{".concat(x, "}");
2096            }, Date.prototype.setHours, "hours", function (x) {
2097                return Date.prototype.getHours;
2098            }],
2099            H: ["1?[0-9]|2[0-3]", Date.prototype.setHours, "hours", Date.prototype.getHours],
2100            HH: ["0[0-9]|1[0-9]|2[0-3]", Date.prototype.setHours, "hours", function () {
2101                return pad(Date.prototype.getHours.call(this), 2);
2102            }],
2103            Hx: [function (x) {
2104                return "[0-9]{".concat(x, "}");
2105            }, Date.prototype.setHours, "hours", function (x) {
2106                return function () {
2107                    return pad(Date.prototype.getHours.call(this), x);
2108                };
2109            }],
2110            M: ["[1-5]?[0-9]", Date.prototype.setMinutes, "minutes", Date.prototype.getMinutes],
2111            MM: ["0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]", Date.prototype.setMinutes, "minutes", function () {
2112                return pad(Date.prototype.getMinutes.call(this), 2);
2113            }],
2114            s: ["[1-5]?[0-9]", Date.prototype.setSeconds, "seconds", Date.prototype.getSeconds],
2115            ss: ["0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]", Date.prototype.setSeconds, "seconds", function () {
2116                return pad(Date.prototype.getSeconds.call(this), 2);
2117            }],
2118            l: ["[0-9]{3}", Date.prototype.setMilliseconds, "milliseconds", function () {
2119                return pad(Date.prototype.getMilliseconds.call(this), 3);
2120            }],
2121            L: ["[0-9]{2}", Date.prototype.setMilliseconds, "milliseconds", function () {
2122                return pad(Date.prototype.getMilliseconds.call(this), 2);
2123            }],
2124            t: ["[ap]"],
2125            tt: ["[ap]m"],
2126            T: ["[AP]"],
2127            TT: ["[AP]M"],
2128            Z: [""],
2129            o: [""],
2130            S: [""]
2131        }, formatAlias = {
2132            isoDate: "yyyy-mm-dd",
2133            isoTime: "HH:MM:ss",
2134            isoDateTime: "yyyy-mm-dd'T'HH:MM:ss",
2135            isoUtcDateTime: "UTC:yyyy-mm-dd'T'HH:MM:ss'Z'"
2136        };
2137        function formatcode(match) {
2138            var dynMatches = new RegExp("\\d+$").exec(match[0]);
2139            if (dynMatches && void 0 !== dynMatches[0]) {
2140                var fcode = formatCode[match[0][0] + "x"].slice("");
2141                return fcode[0] = fcode[0](dynMatches[0]), fcode[3] = fcode[3](dynMatches[0]), fcode;
2142            }
2143            if (formatCode[match[0]]) return formatCode[match[0]];
2144        }
2145        function getTokenizer(opts) {
2146            if (!opts.tokenizer) {
2147                var tokens = [], dyntokens = [];
2148                for (var ndx in formatCode) if (/\.*x$/.test(ndx)) {
2149                    var dynToken = ndx[0] + "\\d+";
2150                    -1 === dyntokens.indexOf(dynToken) && dyntokens.push(dynToken);
2151                } else -1 === tokens.indexOf(ndx[0]) && tokens.push(ndx[0]);
2152                opts.tokenizer = "(" + (0 < dyntokens.length ? dyntokens.join("|") + "|" : "") + tokens.join("+|") + ")+?|.",
2153                    opts.tokenizer = new RegExp(opts.tokenizer, "g");
2154            }
2155            return opts.tokenizer;
2156        }
2157        function prefillYear(dateParts, currentResult, opts) {
2158            if (dateParts.year !== dateParts.rawyear) {
2159                var crrntyear = currentYear.toString(), enteredPart = dateParts.rawyear.replace(/[^0-9]/g, ""), currentYearPart = crrntyear.slice(0, enteredPart.length), currentYearNextPart = crrntyear.slice(enteredPart.length);
2160                if (2 === enteredPart.length && enteredPart === currentYearPart) {
2161                    var entryCurrentYear = new Date(currentYear, dateParts.month - 1, dateParts.day);
2162                    dateParts.day == entryCurrentYear.getDate() && (!opts.max || opts.max.date.getTime() >= entryCurrentYear.getTime()) && (dateParts.date.setFullYear(currentYear),
2163                        dateParts.year = crrntyear, currentResult.insert = [{
2164                            pos: currentResult.pos + 1,
2165                            c: currentYearNextPart[0]
2166                        }, {
2167                            pos: currentResult.pos + 2,
2168                            c: currentYearNextPart[1]
2169                        }]);
2170                }
2171            }
2172            return currentResult;
2173        }
2174        function isValidDate(dateParts, currentResult, opts) {
2175            if (void 0 === dateParts.rawday || !isFinite(dateParts.rawday) && new Date(dateParts.date.getFullYear(), isFinite(dateParts.rawmonth) ? dateParts.month : dateParts.date.getMonth() + 1, 0).getDate() >= dateParts.day || "29" == dateParts.day && !Number.isFinite(dateParts.rawyear) || new Date(dateParts.date.getFullYear(), isFinite(dateParts.rawmonth) ? dateParts.month : dateParts.date.getMonth() + 1, 0).getDate() >= dateParts.day) return currentResult;
2176            if ("29" == dateParts.day) {
2177                var tokenMatch = getTokenMatch(currentResult.pos, opts);
2178                if ("yyyy" === tokenMatch.targetMatch[0] && currentResult.pos - tokenMatch.targetMatchIndex == 2) return currentResult.remove = currentResult.pos + 1,
2179                    currentResult;
2180            } else if ("02" == dateParts.month && "30" == dateParts.day && void 0 !== currentResult.c) return dateParts.day = "03",
2181                dateParts.date.setDate(3), dateParts.date.setMonth(1), currentResult.insert = [{
2182                    pos: currentResult.pos,
2183                    c: "0"
2184                }, {
2185                    pos: currentResult.pos + 1,
2186                    c: currentResult.c
2187                }], currentResult.caret = _positioning.seekNext.call(this, currentResult.pos + 1),
2188                currentResult;
2189            return !1;
2190        }
2191        function isDateInRange(dateParts, result, opts, maskset, fromCheckval) {
2192            if (!result) return result;
2193            if (opts.min) {
2194                if (dateParts.rawyear) {
2195                    var rawYear = dateParts.rawyear.replace(/[^0-9]/g, ""), minYear = opts.min.year.substr(0, rawYear.length), maxYear;
2196                    if (rawYear < minYear) {
2197                        var tokenMatch = getTokenMatch(result.pos, opts);
2198                        if (rawYear = dateParts.rawyear.substr(0, result.pos - tokenMatch.targetMatchIndex + 1).replace(/[^0-9]/g, "0"),
2199                            minYear = opts.min.year.substr(0, rawYear.length), minYear <= rawYear) return result.remove = tokenMatch.targetMatchIndex + rawYear.length,
2200                                result;
2201                        if (rawYear = "yyyy" === tokenMatch.targetMatch[0] ? dateParts.rawyear.substr(1, 1) : dateParts.rawyear.substr(0, 1),
2202                            minYear = opts.min.year.substr(2, 1), maxYear = opts.max ? opts.max.year.substr(2, 1) : rawYear,
2203                            1 === rawYear.length && minYear <= rawYear && rawYear <= maxYear && !0 !== fromCheckval) return "yyyy" === tokenMatch.targetMatch[0] ? (result.insert = [{
2204                                pos: result.pos + 1,
2205                                c: rawYear,

2378                casing: function casing(elem, test, pos, validPositions) {
2379                    return 0 == test.nativeDef.indexOf("[ap]") ? elem.toLowerCase() : 0 == test.nativeDef.indexOf("[AP]") ? elem.toUpperCase() : elem;
2380                },
2381                onBeforeMask: function onBeforeMask(initialValue, opts) {
2382                    return "[object Date]" === Object.prototype.toString.call(initialValue) && (initialValue = importDate(initialValue, opts)),
2383                        initialValue;
2384                },
2385                insertMode: !1,
2386                shiftPositions: !1,
2387                keepStatic: !1,
2388                inputmode: "numeric"
2389            }
2390        });
2391    }, function (module, exports, __webpack_require__) {
2392        "use strict";
2393        var _inputmask = _interopRequireDefault(__webpack_require__(2)), _keycode = _interopRequireDefault(__webpack_require__(0)), _escapeRegex = _interopRequireDefault(__webpack_require__(13));
2394        function _interopRequireDefault(obj) {
2395            return obj && obj.__esModule ? obj : {
2396                default: obj
2397            };
2398        }
2399        var $ = _inputmask.default.dependencyLib;
2400        function autoEscape(txt, opts) {
2401            for (var escapedTxt = "", i = 0; i < txt.length; i++) _inputmask.default.prototype.definitions[txt.charAt(i)] || opts.definitions[txt.charAt(i)] || opts.optionalmarker[0] === txt.charAt(i) || opts.optionalmarker[1] === txt.charAt(i) || opts.quantifiermarker[0] === txt.charAt(i) || opts.quantifiermarker[1] === txt.charAt(i) || opts.groupmarker[0] === txt.charAt(i) || opts.groupmarker[1] === txt.charAt(i) || opts.alternatormarker === txt.charAt(i) ? escapedTxt += "\\" + txt.charAt(i) : escapedTxt += txt.charAt(i);
2402            return escapedTxt;
2403        }
2404        function alignDigits(buffer, digits, opts, force) {
2405            if (0 < buffer.length && 0 < digits && (!opts.digitsOptional || force)) {
2406                var radixPosition = buffer.indexOf(opts.radixPoint), negationBack = !1;
2407                opts.negationSymbol.back === buffer[buffer.length - 1] && (negationBack = !0, buffer.length--),
2408                    -1 === radixPosition && (buffer.push(opts.radixPoint), radixPosition = buffer.length - 1);
2409                for (var i = 1; i <= digits; i++) isFinite(buffer[radixPosition + i]) || (buffer[radixPosition + i] = "0");
2410            }
2411            return negationBack && buffer.push(opts.negationSymbol.back), buffer;
2412        }
2413        function findValidator(symbol, maskset) {
2414            var posNdx = 0;
2415            if ("+" === symbol) {
2416                for (posNdx in maskset.validPositions);
2417                posNdx = parseInt(posNdx);
2418            }
2419            for (var tstNdx in maskset.tests) if (tstNdx = parseInt(tstNdx), posNdx <= tstNdx) for (var ndx = 0, ndxl = maskset.tests[tstNdx].length; ndx < ndxl; ndx++) if ((void 0 === maskset.validPositions[tstNdx] || "-" === symbol) && maskset.tests[tstNdx][ndx].match.def === symbol) return tstNdx + (void 0 !== maskset.validPositions[tstNdx] && "-" !== symbol ? 1 : 0);
2420            return posNdx;
2421        }
2422        function findValid(symbol, maskset) {
2423            var ret = -1;
2424            for (var ndx in maskset.validPositions) {
2425                var tst = maskset.validPositions[ndx];
2426                if (tst && tst.match.def === symbol) {
2427                    ret = parseInt(ndx);
2428                    break;
2429                }
2430            }
2431            return ret;
2432        }
2433        function parseMinMaxOptions(opts) {
2434            void 0 === opts.parseMinMaxOptions && (null !== opts.min && (opts.min = opts.min.toString().replace(new RegExp((0,
2435                _escapeRegex.default)(opts.groupSeparator), "g"), ""), "," === opts.radixPoint && (opts.min = opts.min.replace(opts.radixPoint, ".")),
2436                opts.min = isFinite(opts.min) ? parseFloat(opts.min) : NaN, isNaN(opts.min) && (opts.min = Number.MIN_VALUE)),
2437                null !== opts.max && (opts.max = opts.max.toString().replace(new RegExp((0, _escapeRegex.default)(opts.groupSeparator), "g"), ""),
2438                    "," === opts.radixPoint && (opts.max = opts.max.replace(opts.radixPoint, ".")),
2439                    opts.max = isFinite(opts.max) ? parseFloat(opts.max) : NaN, isNaN(opts.max) && (opts.max = Number.MAX_VALUE)),
2440                opts.parseMinMaxOptions = "done");
2441        }
2442        function genMask(opts) {
2443            opts.repeat = 0, opts.groupSeparator === opts.radixPoint && opts.digits && "0" !== opts.digits && ("." === opts.radixPoint ? opts.groupSeparator = "," : "," === opts.radixPoint ? opts.groupSeparator = "." : opts.groupSeparator = ""),
2444                " " === opts.groupSeparator && (opts.skipOptionalPartCharacter = void 0), 1 < opts.placeholder.length && (opts.placeholder = opts.placeholder.charAt(0)),
2445                "radixFocus" === opts.positionCaretOnClick && "" === opts.placeholder && (opts.positionCaretOnClick = "lvp");
2446            var decimalDef = "0", radixPointDef = opts.radixPoint;
2447            !0 === opts.numericInput && void 0 === opts.__financeInput ? (decimalDef = "1",
2448                opts.positionCaretOnClick = "radixFocus" === opts.positionCaretOnClick ? "lvp" : opts.positionCaretOnClick,
2449                opts.digitsOptional = !1, isNaN(opts.digits) && (opts.digits = 2), opts._radixDance = !1,
2450                radixPointDef = "," === opts.radixPoint ? "?" : "!", "" !== opts.radixPoint && void 0 === opts.definitions[radixPointDef] && (opts.definitions[radixPointDef] = {},
2451                    opts.definitions[radixPointDef].validator = "[" + opts.radixPoint + "]", opts.definitions[radixPointDef].placeholder = opts.radixPoint,
2452                    opts.definitions[radixPointDef].static = !0, opts.definitions[radixPointDef].generated = !0)) : (opts.__financeInput = !1,
2453                        opts.numericInput = !0);
2454            var mask = "[+]", altMask;
2455            if (mask += autoEscape(opts.prefix, opts), "" !== opts.groupSeparator ? (void 0 === opts.definitions[opts.groupSeparator] && (opts.definitions[opts.groupSeparator] = {},
2456                opts.definitions[opts.groupSeparator].validator = "[" + opts.groupSeparator + "]",
2457                opts.definitions[opts.groupSeparator].placeholder = opts.groupSeparator, opts.definitions[opts.groupSeparator].static = !0,
2458                opts.definitions[opts.groupSeparator].generated = !0), mask += opts._mask(opts)) : mask += "9{+}",
2459                void 0 !== opts.digits && 0 !== opts.digits) {
2460                var dq = opts.digits.toString().split(",");
2461                isFinite(dq[0]) && dq[1] && isFinite(dq[1]) ? mask += radixPointDef + decimalDef + "{" + opts.digits + "}" : (isNaN(opts.digits) || 0 < parseInt(opts.digits)) && (opts.digitsOptional ? (altMask = mask + radixPointDef + decimalDef + "{0," + opts.digits + "}",
2462                    opts.keepStatic = !0) : mask += radixPointDef + decimalDef + "{" + opts.digits + "}");
2463            }
2464            return mask += autoEscape(opts.suffix, opts), mask += "[-]", altMask && (mask = [altMask + autoEscape(opts.suffix, opts) + "[-]", mask]),
2465                opts.greedy = !1, parseMinMaxOptions(opts), mask;
2466        }
2467        function hanndleRadixDance(pos, c, radixPos, maskset, opts) {
2468            return opts._radixDance && opts.numericInput && c !== opts.negationSymbol.back && pos <= radixPos && (0 < radixPos || c == opts.radixPoint) && (void 0 === maskset.validPositions[pos - 1] || maskset.validPositions[pos - 1].input !== opts.negationSymbol.back) && (pos -= 1),
2469                pos;
2470        }
2471        function decimalValidator(chrs, maskset, pos, strict, opts) {
2472            var radixPos = maskset.buffer ? maskset.buffer.indexOf(opts.radixPoint) : -1, result = -1 !== radixPos && new RegExp("[0-9\uff11-\uff19]").test(chrs);
2473            return opts._radixDance && result && null == maskset.validPositions[radixPos] ? {
2474                insert: {
2475                    pos: radixPos === pos ? radixPos + 1 : radixPos,
2476                    c: opts.radixPoint
2477                },
2478                pos: pos
2479            } : result;
2480        }
2481        function checkForLeadingZeroes(buffer, opts) {
2482            var numberMatches = new RegExp("(^" + ("" !== opts.negationSymbol.front ? (0, _escapeRegex.default)(opts.negationSymbol.front) + "?" : "") + (0,
2483                _escapeRegex.default)(opts.prefix) + ")(.*)(" + (0, _escapeRegex.default)(opts.suffix) + ("" != opts.negationSymbol.back ? (0,
2484                    _escapeRegex.default)(opts.negationSymbol.back) + "?" : "") + "$)").exec(buffer.slice().reverse().join("")), number = numberMatches ? numberMatches[2] : "", leadingzeroes = !1;
2485            return number && (number = number.split(opts.radixPoint.charAt(0))[0], leadingzeroes = new RegExp("^[0" + opts.groupSeparator + "]*").exec(number)),
2486                !(!leadingzeroes || !(1 < leadingzeroes[0].length || 0 < leadingzeroes[0].length && leadingzeroes[0].length < number.length)) && leadingzeroes;
2487        }
2488        _inputmask.default.extendAliases({
2489            numeric: {
2490                mask: genMask,
2491                _mask: function _mask(opts) {
2492                    return "(" + opts.groupSeparator + "999){+|1}";
2493                },
2494                digits: "*",
2495                digitsOptional: !0,
2496                enforceDigitsOnBlur: !1,
2497                radixPoint: ".",
2498                positionCaretOnClick: "radixFocus",
2499                _radixDance: !0,
2500                groupSeparator: "",
2501                allowMinus: !0,
2502                negationSymbol: {
2503                    front: "-",
2504                    back: ""
2505                },
2506                prefix: "",
2507                suffix: "",
2508                min: null,
2509                max: null,
2510                SetMaxOnOverflow: !1,
2511                step: 1,
2512                inputType: "text",
2513                unmaskAsNumber: !1,
2514                roundingFN: Math.round,
2515                inputmode: "decimal",
2516                shortcuts: {
2517                    k: "000",
2518                    m: "000000"
2519                },
2520                placeholder: "0",
2521                greedy: !1,
2522                rightAlign: !0,
2523                insertMode: !0,
2524                autoUnmask: !1,
2525                skipOptionalPartCharacter: "",
2526                definitions: {
2527                    0: {
2528                        validator: decimalValidator
2529                    },
2530                    1: {
2531                        validator: decimalValidator,
2532                        definitionSymbol: "9"
2533                    },
2534                    "+": {
2535                        validator: function validator(chrs, maskset, pos, strict, opts) {
2536                            return opts.allowMinus && ("-" === chrs || chrs === opts.negationSymbol.front);
2537                        }
2538                    },
2539                    "-": {
2540                        validator: function validator(chrs, maskset, pos, strict, opts) {
2541                            return opts.allowMinus && chrs === opts.negationSymbol.back;
2542                        }
2543                    }
2544                },
2545                preValidation: function preValidation(buffer, pos, c, isSelection, opts, maskset, caretPos, strict) {
2546                    if (!1 !== opts.__financeInput && c === opts.radixPoint) return !1;
2547                    var pattern;
2548                    if (pattern = opts.shortcuts && opts.shortcuts[c]) {
2549                        if (1 < pattern.length) for (var inserts = [], i = 0; i < pattern.length; i++) inserts.push({
2550                            pos: pos + i,
2551                            c: pattern[i],
2552                            strict: !1
2553                        });
2554                        return {
2555                            insert: inserts
2556                        };
2557                    }
2558                    var radixPos = buffer.indexOf(opts.radixPoint), initPos = pos;
2559                    if (pos = hanndleRadixDance(pos, c, radixPos, maskset, opts), "-" === c || c === opts.negationSymbol.front) {
2560                        if (!0 !== opts.allowMinus) return !1;
2561                        var isNegative = !1, front = findValid("+", maskset), back = findValid("-", maskset);
2562                        return -1 !== front && (isNegative = [front, back]), !1 !== isNegative ? {
2563                            remove: isNegative,
2564                            caret: initPos - opts.negationSymbol.front.length
2565                        } : {
2566                                insert: [{
2567                                    pos: findValidator("+", maskset),
2568                                    c: opts.negationSymbol.front,
2569                                    fromIsValid: !0
2570                                }, {
2571                                    pos: findValidator("-", maskset),
2572                                    c: opts.negationSymbol.back,
2573                                    fromIsValid: void 0
2574                                }],
2575                                caret: initPos + opts.negationSymbol.back.length
2576                            };
2577                    }
2578                    if (c === opts.groupSeparator) return {
2579                        caret: initPos
2580                    };
2581                    if (strict) return !0;
2582                    if (-1 !== radixPos && !0 === opts._radixDance && !1 === isSelection && c === opts.radixPoint && void 0 !== opts.digits && (isNaN(opts.digits) || 0 < parseInt(opts.digits)) && radixPos !== pos) return {
2583                        caret: opts._radixDance && pos === radixPos - 1 ? radixPos + 1 : radixPos
2584                    };
2585                    if (!1 === opts.__financeInput) if (isSelection) {
2586                        if (opts.digitsOptional) return {
2587                            rewritePosition: caretPos.end
2588                        };
2589                        if (!opts.digitsOptional) {
2590                            if (caretPos.begin > radixPos && caretPos.end <= radixPos) return c === opts.radixPoint ? {
2591                                insert: {
2592                                    pos: radixPos + 1,
2593                                    c: "0",
2594                                    fromIsValid: !0
2595                                },
2596                                rewritePosition: radixPos
2597                            } : {
2598                                    rewritePosition: radixPos + 1
2599                                };
2600                            if (caretPos.begin < radixPos) return {
2601                                rewritePosition: caretPos.begin - 1
2602                            };
2603                        }
2604                    } else if (!opts.showMaskOnHover && !opts.showMaskOnFocus && !opts.digitsOptional && 0 < opts.digits && "" === this.__valueGet.call(this.el)) return {
2605                        rewritePosition: radixPos
2606                    };
2607                    return {
2608                        rewritePosition: pos
2609                    };
2610                },
2611                postValidation: function postValidation(buffer, pos, c, currentResult, opts, maskset, strict) {
2612                    if (!1 === currentResult) return currentResult;
2613                    if (strict) return !0;
2614                    if (null !== opts.min || null !== opts.max) {
2615                        var unmasked = opts.onUnMask(buffer.slice().reverse().join(""), void 0, $.extend({}, opts, {
2616                            unmaskAsNumber: !0
2617                        }));
2618                        if (null !== opts.min && unmasked < opts.min && (unmasked.toString().length > opts.min.toString().length || unmasked < 0)) return !1;
2619                        if (null !== opts.max && unmasked > opts.max) return !!opts.SetMaxOnOverflow && {
2620                            refreshFromBuffer: !0,
2621                            buffer: alignDigits(opts.max.toString().replace(".", opts.radixPoint).split(""), opts.digits, opts).reverse()
2622                        };
2623                    }
2624                    return currentResult;
2625                },
2626                onUnMask: function onUnMask(maskedValue, unmaskedValue, opts) {
2627                    if ("" === unmaskedValue && !0 === opts.nullable) return unmaskedValue;
2628                    var processValue = maskedValue.replace(opts.prefix, "");
2629                    return processValue = processValue.replace(opts.suffix, ""), processValue = processValue.replace(new RegExp((0,
2630                        _escapeRegex.default)(opts.groupSeparator), "g"), ""), "" !== opts.placeholder.charAt(0) && (processValue = processValue.replace(new RegExp(opts.placeholder.charAt(0), "g"), "0")),
2631                        opts.unmaskAsNumber ? ("" !== opts.radixPoint && -1 !== processValue.indexOf(opts.radixPoint) && (processValue = processValue.replace(_escapeRegex.default.call(this, opts.radixPoint), ".")),
2632                            processValue = processValue.replace(new RegExp("^" + (0, _escapeRegex.default)(opts.negationSymbol.front)), "-"),
2633                            processValue = processValue.replace(new RegExp((0, _escapeRegex.default)(opts.negationSymbol.back) + "$"), ""),
2634                            Number(processValue)) : processValue;
2635                },
2636                isComplete: function isComplete(buffer, opts) {
2637                    var maskedValue = (opts.numericInput ? buffer.slice().reverse() : buffer).join("");
2638                    return maskedValue = maskedValue.replace(new RegExp("^" + (0, _escapeRegex.default)(opts.negationSymbol.front)), "-"),
2639                        maskedValue = maskedValue.replace(new RegExp((0, _escapeRegex.default)(opts.negationSymbol.back) + "$"), ""),
2640                        maskedValue = maskedValue.replace(opts.prefix, ""), maskedValue = maskedValue.replace(opts.suffix, ""),
2641                        maskedValue = maskedValue.replace(new RegExp((0, _escapeRegex.default)(opts.groupSeparator) + "([0-9]{3})", "g"), "$1"),
2642                        "," === opts.radixPoint && (maskedValue = maskedValue.replace((0, _escapeRegex.default)(opts.radixPoint), ".")),
2643                        isFinite(maskedValue);
2644                },
2645                onBeforeMask: function onBeforeMask(initialValue, opts) {
2646                    var radixPoint = opts.radixPoint || ",";
2647                    isFinite(opts.digits) && (opts.digits = parseInt(opts.digits)), "number" != typeof initialValue && "number" !== opts.inputType || "" === radixPoint || (initialValue = initialValue.toString().replace(".", radixPoint));
2648                    var isNagtive = "-" === initialValue.charAt(0) || initialValue.charAt(0) === opts.negationSymbol.front, valueParts = initialValue.split(radixPoint), integerPart = valueParts[0].replace(/[^\-0-9]/g, ""), decimalPart = 1 < valueParts.length ? valueParts[1].replace(/[^0-9]/g, "") : "", forceDigits = 1 < valueParts.length;
2649                    initialValue = integerPart + ("" !== decimalPart ? radixPoint + decimalPart : decimalPart);
2650                    var digits = 0;
2651                    if ("" !== radixPoint && (digits = opts.digitsOptional ? opts.digits < decimalPart.length ? opts.digits : decimalPart.length : opts.digits,
2652                        "" !== decimalPart || !opts.digitsOptional)) {
2653                        var digitsFactor = Math.pow(10, digits || 1);
2654                        initialValue = initialValue.replace((0, _escapeRegex.default)(radixPoint), "."),
2655                            isNaN(parseFloat(initialValue)) || (initialValue = (opts.roundingFN(parseFloat(initialValue) * digitsFactor) / digitsFactor).toFixed(digits)),
2656                            initialValue = initialValue.toString().replace(".", radixPoint);
2657                    }
2658                    if (0 === opts.digits && -1 !== initialValue.indexOf(radixPoint) && (initialValue = initialValue.substring(0, initialValue.indexOf(radixPoint))),
2659                        null !== opts.min || null !== opts.max) {
2660                        var numberValue = initialValue.toString().replace(radixPoint, ".");
2661                        null !== opts.min && numberValue < opts.min ? initialValue = opts.min.toString().replace(".", radixPoint) : null !== opts.max && numberValue > opts.max && (initialValue = opts.max.toString().replace(".", radixPoint));
2662                    }
2663                    return isNagtive && "-" !== initialValue.charAt(0) && (initialValue = "-" + initialValue),
2664                        alignDigits(initialValue.toString().split(""), digits, opts, forceDigits).join("");
2665                },
2666                onBeforeWrite: function onBeforeWrite(e, buffer, caretPos, opts) {
2667                    function stripBuffer(buffer, stripRadix) {
2668                        if (!1 !== opts.__financeInput || stripRadix) {
2669                            var position = buffer.indexOf(opts.radixPoint);
2670                            -1 !== position && buffer.splice(position, 1);
2671                        }
2672                        if ("" !== opts.groupSeparator) for (; -1 !== (position = buffer.indexOf(opts.groupSeparator));) buffer.splice(position, 1);
2673                        return buffer;
2674                    }
2675                    var result, leadingzeroes = checkForLeadingZeroes(buffer, opts);
2676                    if (leadingzeroes) for (var caretNdx = buffer.join("").lastIndexOf(leadingzeroes[0].split("").reverse().join("")) - (leadingzeroes[0] == leadingzeroes.input ? 0 : 1), offset = leadingzeroes[0] == leadingzeroes.input ? 1 : 0, i = leadingzeroes[0].length - offset; 0 < i; i--) delete this.maskset.validPositions[caretNdx + i],
2677                        delete buffer[caretNdx + i];
2678                    if (e) switch (e.type) {
2679                        case "blur":
2680                        case "checkval":
2681                            if (null !== opts.min) {
2682                                var unmasked = opts.onUnMask(buffer.slice().reverse().join(""), void 0, $.extend({}, opts, {
2683                                    unmaskAsNumber: !0
2684                                }));
2685                                if (null !== opts.min && unmasked < opts.min) return {
2686                                    refreshFromBuffer: !0,
2687                                    buffer: alignDigits(opts.min.toString().replace(".", opts.radixPoint).split(""), opts.digits, opts).reverse()
2688                                };
2689                            }
2690                            if (buffer[buffer.length - 1] === opts.negationSymbol.front) {
2691                                var nmbrMtchs = new RegExp("(^" + ("" != opts.negationSymbol.front ? (0, _escapeRegex.default)(opts.negationSymbol.front) + "?" : "") + (0,
2692                                    _escapeRegex.default)(opts.prefix) + ")(.*)(" + (0, _escapeRegex.default)(opts.suffix) + ("" != opts.negationSymbol.back ? (0,
2693                                        _escapeRegex.default)(opts.negationSymbol.back) + "?" : "") + "$)").exec(stripBuffer(buffer.slice(), !0).reverse().join("")), number = nmbrMtchs ? nmbrMtchs[2] : "";
2694                                0 == number && (result = {
2695                                    refreshFromBuffer: !0,
2696                                    buffer: [0]
2697                                });
2698                            } else "" !== opts.radixPoint && buffer[0] === opts.radixPoint && (result && result.buffer ? result.buffer.shift() : (buffer.shift(),
2699                                result = {
2700                                    refreshFromBuffer: !0,
2701                                    buffer: stripBuffer(buffer)
2702                                }));
2703                            if (opts.enforceDigitsOnBlur) {
2704                                result = result || {};
2705                                var bffr = result && result.buffer || buffer.slice().reverse();
2706                                result.refreshFromBuffer = !0, result.buffer = alignDigits(bffr, opts.digits, opts, !0).reverse();
2707                            }
2708                    }
2709                    return result;
2710                },
2711                onKeyDown: function onKeyDown(e, buffer, caretPos, opts) {
2712                    var $input = $(this), bffr;
2713                    if (e.ctrlKey) switch (e.keyCode) {
2714                        case _keycode.default.UP:
2715                            return this.inputmask.__valueSet.call(this, parseFloat(this.inputmask.unmaskedvalue()) + parseInt(opts.step)),
2716                                $input.trigger("setvalue"), !1;
2717
2718                        case _keycode.default.DOWN:
2719                            return this.inputmask.__valueSet.call(this, parseFloat(this.inputmask.unmaskedvalue()) - parseInt(opts.step)),
2720                                $input.trigger("setvalue"), !1;
2721                    }
2722                    if (!e.shiftKey && (e.keyCode === _keycode.default.DELETE || e.keyCode === _keycode.default.BACKSPACE || e.keyCode === _keycode.default.BACKSPACE_SAFARI) && caretPos.begin !== buffer.length) {
2723                        if (buffer[e.keyCode === _keycode.default.DELETE ? caretPos.begin - 1 : caretPos.end] === opts.negationSymbol.front) return bffr = buffer.slice().reverse(),
2724                            "" !== opts.negationSymbol.front && bffr.shift(), "" !== opts.negationSymbol.back && bffr.pop(),
2725                            $input.trigger("setvalue", [bffr.join(""), caretPos.begin]), !1;
2726                        if (!0 === opts._radixDance) {
2727                            var radixPos = buffer.indexOf(opts.radixPoint);
2728                            if (opts.digitsOptional) {
2729                                if (0 === radixPos) return bffr = buffer.slice().reverse(), bffr.pop(), $input.trigger("setvalue", [bffr.join(""), caretPos.begin >= bffr.length ? bffr.length : caretPos.begin]),
2730                                    !1;
2731                            } else if (-1 !== radixPos && (caretPos.begin < radixPos || caretPos.end < radixPos || e.keyCode === _keycode.default.DELETE && c