https://biletur.ru/vendor/Inputmask/dist/jquery.inputmask.js

1/*!
2 * dist/jquery.inputmask
3 * https://github.com/RobinHerbots/Inputmask
4 * Copyright (c) 2010 - 2020 Robin Herbots
5 * Licensed under the MIT license
6 * Version: 5.0.4-beta.55
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}(window, function(__WEBPACK_EXTERNAL_MODULE__8__) {
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.default = void 0, __webpack_require__(9);
21        var _mask = __webpack_require__(10), _inputmask = _interopRequireDefault(__webpack_require__(12)), _window = _interopRequireDefault(__webpack_require__(13)), _maskLexer = __webpack_require__(17), _validationTests = __webpack_require__(3), _positioning = __webpack_require__(2), _validation = __webpack_require__(4), _inputHandling = __webpack_require__(5), _eventruler = __webpack_require__(11), _definitions = _interopRequireDefault(__webpack_require__(18)), _defaults = _interopRequireDefault(__webpack_require__(19));
22        function _typeof(obj) {
23            return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function _typeof(obj) {
24                return typeof obj;
25            } : function _typeof(obj) {
26                return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
27            }, _typeof(obj);
28        }
29        function _interopRequireDefault(obj) {
30            return obj && obj.__esModule ? obj : {
31                default: obj
32            };
33        }
34        var document = _window.default.document, dataKey = "_inputmask_opts";
35        function Inputmask(alias, options, internal) {
36            if (!(this instanceof Inputmask)) return new Inputmask(alias, options, internal);
37            this.dependencyLib = _inputmask.default, this.el = void 0, this.events = {}, this.maskset = void 0, 
38            !0 !== internal && ("[object Object]" === Object.prototype.toString.call(alias) ? options = alias : (options = options || {}, 
39            alias && (options.alias = alias)), this.opts = _inputmask.default.extend(!0, {}, this.defaults, options), 
40            this.noMasksCache = options && void 0 !== options.definitions, this.userOptions = options || {}, 
41            resolveAlias(this.opts.alias, options, this.opts)), this.refreshValue = !1, this.undoValue = void 0, 
42            this.$el = void 0, this.skipKeyPressEvent = !1, this.skipInputEvent = !1, this.validationEvent = !1, 
43            this.ignorable = !1, this.maxLength, this.mouseEnter = !1, this.originalPlaceholder = void 0, 
44            this.isComposing = !1;
45        }
46        function resolveAlias(aliasStr, options, opts) {
47            var aliasDefinition = Inputmask.prototype.aliases[aliasStr];
48            return aliasDefinition ? (aliasDefinition.alias && resolveAlias(aliasDefinition.alias, void 0, opts), 
49            _inputmask.default.extend(!0, opts, aliasDefinition), _inputmask.default.extend(!0, opts, options), 
50            !0) : (null === opts.mask && (opts.mask = aliasStr), !1);
51        }
52        function importAttributeOptions(npt, opts, userOptions, dataAttribute) {
53            function importOption(option, optionData) {
54                var attrOption = "" === dataAttribute ? option : dataAttribute + "-" + option;
55                optionData = void 0 !== optionData ? optionData : npt.getAttribute(attrOption), 
56                null !== optionData && ("string" == typeof optionData && (0 === option.indexOf("on") ? optionData = _window.default[optionData] : "false" === optionData ? optionData = !1 : "true" === optionData && (

56optionData = !0)), 
57                userOptions[option] = optionData);
58            }
59            if (!0 === opts.importDataAttributes) {
60                var attrOptions = npt.getAttribute(dataAttribute), option, dataoptions, optionData, p;
61                if (attrOptions && "" !== attrOptions && (attrOptions = attrOptions.replace(/'/g, '"'), 
62                dataoptions = JSON.parse("{" + attrOptions + "}")), dataoptions) for (p in optionData = void 0, 
63                dataoptions) if ("alias" === p.toLowerCase()) {
64                    optionData = dataoptions[p];
65                    break;
66                }
67                for (option in importOption("alias", optionData), userOptions.alias && resolveAlias(userOptions.alias, userOptions, opts), 
68                opts) {
69                    if (dataoptions) for (p in optionData = void 0, dataoptions) if (p.toLowerCase() === option.toLowerCase()) {
70                        optionData = dataoptions[p];
71                        break;
72                    }
73                    importOption(option, optionData);
74                }
75            }
76            return _inputmask.default.extend(!0, opts, userOptions), "rtl" !== npt.dir && !opts.rightAlign || (npt.style.textAlign = "right"), 
77            "rtl" !== npt.dir && !opts.numericInput || (npt.dir = "ltr", npt.removeAttribute("dir"), 
78            opts.isRTL = !0), Object.keys(userOptions).length;
79        }
80        Inputmask.prototype = {
81            dataAttribute: "data-inputmask",
82            defaults: _defaults.default,
83            definitions: _definitions.default,
84            aliases: {},
85            masksCache: {},
86            get isRTL() {
87                return this.opts.isRTL || this.opts.numericInput;
88            },
89            mask: function mask(elems) {
90                var that = this;
91                return "string" == typeof elems && (elems = document.getElementById(elems) || document.querySelectorAll(elems)), 
92                elems = elems.nodeName ? [ elems ] : elems, elems.forEach(function(el, ndx) {
93                    var scopedOpts = _inputmask.default.extend(!0, {}, that.opts);
94                    if (importAttributeOptions(el, scopedOpts, _inputmask.default.extend(!0, {}, that.userOptions), that.dataAttribute)) {
95                        var maskset = (0, _maskLexer.generateMaskSet)(scopedOpts, that.noMasksCache);
96                        void 0 !== maskset && (void 0 !== el.inputmask && (el.inputmask.opts.autoUnmask = !0, 
97                        el.inputmask.remove()), el.inputmask = new Inputmask(void 0, void 0, !0), el.inputmask.opts = scopedOpts, 
98                        el.inputmask.noMasksCache = that.noMasksCache, el.inputmask.userOptions = _inputmask.default.extend(!0, {}, that.userOptions), 
99                        el.inputmask.el = el, el.inputmask.$el = (0, _inputmask.default)(el), el.inputmask.maskset = maskset, 
100                        _inputmask.default.data(el, dataKey, that.userOptions), _mask.mask.call(el.inputmask));
101                    }
102                }), elems && elems[0] && elems[0].inputmask || this;
103            },
104            option: function option(options, noremask) {
105                return "string" == typeof options ? this.opts[options] : "object" === _typeof(options) ? (_inputmask.default.extend(this.userOptions, options), 
106                this.el && !0 !== noremask && this.mask(this.el), this) : void 0;
107            },
108            unmaskedvalue: function unmaskedvalue(value) {
109                if (this.maskset = this.maskset || (0, _maskLexer.generateMaskSet)(this.opts, this.noMasksCache), 
110                void 0 === this.el || void 0 !== value) {
111                    var valueBuffer = ("function" == typeof this.opts.onBeforeMask && this.opts.onBeforeMask.call(this, value, this.opts) || value).split("");
112                    _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);
113                }
114                return _inputHandling.unmaskedvalue.call(this, this.el);
115            },
116            remove: function remove() {
117                if (this.el) {
118                    _inputmask.default.data(this.el, dataKey, null);
119                    var cv = this.opts.autoUnmask ? (0, _inputHandling.unmaskedvalue)(this.el) : this._valueGet(this.opts.autoUnmask), valueProperty;
120                    cv !== _positioning.getBufferTemplate.call(this).join("") ? this._valueSet(cv, this.opts.autoUnmask) : this._valueSet(""), 
121                    _eventruler.EventRuler.off(this.el), Object.getOwnPropertyDescriptor && Ob

189h(function(el) {
190                el.inputmask && el.inputmask.remove();
191            });
192        }, Inputmask.setValue = function(elems, value) {
193            "string" == typeof elems && (elems = document.getElementById(elems) || document.querySelectorAll(elems)), 
194            elems = elems.nodeName ? [ elems ] : elems, elems.forEach(function(el) {
195                el.inputmask ? el.inputmask.setValue(value) : (0, _inputmask.default)(el).trigger("setvalue", [ value ]);
196            });
197        }, Inputmask.dependencyLib = _inputmask.default, _window.default.Inputmask = Inputmask;
198        var _default = Inputmask;
199        exports.default = _default;
200    }, function(module, exports, __webpack_require__) {
201        "use strict";
202        Object.defineProperty(exports, "__esModule", {
203            value: !0
204        }), exports.caret = caret, exports.determineLastRequiredPosition = determineLastRequiredPosition, 
205        exports.determineNewCaretPosition = determineNewCaretPosition, exports.getBuffer = getBuffer, 
206        exports.getBufferTemplate = getBufferTemplate, exports.getLastValidPosition = getLastValidPosition, 
207        exports.isMask = isMask, exports.resetMaskSet = resetMaskSet, exports.seekNext = seekNext, 
208        exports.seekPrevious = seekPrevious, exports.translatePosition = translatePosition;
209        var _validationTests = __webpack_require__(3), _validation = __webpack_require__(4), _mask = __webpack_require__(10);
210        function caret(input, begin, end, notranslate, isDelete) {
211            var inputmask = this, opts = this.opts, range;
212            if (void 0 === begin) return "selectionStart" in input && "selectionEnd" in input ? (begin = input.selectionStart, 
213            end = input.selectionEnd) : window.getSelection ? (range = window.getSelection().getRangeAt(0), 
214            range.commonAncestorContainer.parentNode !== input && range.commonAncestorContainer !== input || (begin = range.startOffset, 
215            end = range.endOffset)) : document.selection && document.selection.createRange && (range = document.selection.createRange(), 
216            begin = 0 - range.duplicate().moveStart("character", -input.inputmask._valueGet().length), 
217            end = begin + range.text.length), {
218                begin: notranslate ? begin : translatePosition.call(this, begin),
219                end: notranslate ? end : translatePosition.call(this, end)
220            };
221            if (Array.isArray(begin) && (end = this.isRTL ? begin[0] : begin[1], begin = this.isRTL ? begin[1] : begin[0]), 
222            void 0 !== begin.begin && (end = this.isRTL ? begin.begin : begin.end, begin = this.isRTL ? begin.end : begin.begin), 
223            "number" == typeof begin) {
224                begin = notranslate ? begin : translatePosition.call(this, begin), end = notranslate ? end : translatePosition.call(this, end), 
225                end = "number" == typeof end ? end : begin;
226                var scrollCalc = parseInt(((input.ownerDocument.defaultView || window).getComputedStyle ? (input.ownerDocument.defaultView || window).getComputedStyle(input, null) : input.currentStyle).fontSize) * end;
227                if (input.scrollLeft = scrollCalc > input.scrollWidth ? scrollCalc : 0, input.inputmask.caretPos = {
228                    begin: begin,
229                    end: end
230                }, opts.insertModeVisual && !1 === opts.insertMode && begin === end && (isDelete || end++), 
231                input === (input.inputmask.shadowRoot || document).activeElement) if ("setSelectionRange" in input) input.setSelectionRange(begin, end); else if (window.getSelection) {
232                    if (range = document.createRange(), void 0 === input.firstChild || null === input.firstChild) {
233                        var textNode = document.createTextNode("");
234                        input.appendChild(textNode);
235                    }
236                    range.setStart(input.firstChild, begin < input.inputmask._valueGet().length ? begin : input.inputmask._valueGet().length), 
237                    range.setEnd(input.firstChild, end < input.inputmask._valueGet().length ? end : input.inputmask._valueGet().length), 
238                    range.collapse(!0);
239                    var sel = window.getSelection();
240                    sel.removeAllRanges(), sel.addRange(range);
241                } else input.createTextRange && (range = input.createTextRange(), range.collapse(!0), 
242                range.moveEnd("character", end), range.moveStart("character", begin), range.select());
243            }
244        }
245        function determineLastRequiredPosition(returnDefinition) {
246            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;
247            for (pos = lvp + 1; pos < buffer.length; pos++) testPos = _validationTests.getTestTemplate.call(this, pos, ndxIntlzr, pos - 1), 
248            ndxIntlzr = testPos.locator.slice(), positions[pos] = $.extend(!0, {}, testPos);
249            var lvTestAlt = lvTest && void 0 !== lvTest.alternation ? lvTest.locator[lvTest.alternation] : void 0;
250            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--;
251            return returnDefinition ? {
252                l: bl,
253                def: positions[bl] ? positions[bl].match : void 0
254            } : bl;
255        }
256        function determineNewCaretPosition(selectedCaret, tabbed) {
257            var inputmask = this, maskset = this.maskset, opts = this.opts;
258            function doRadixFocus(clickPos) {
259                if ("" !== opts.radixPoint && 0 !== opts.digits) {
260                    var vps = maskset.validPositions;
261                    if (void 0 === vps[clickPos] || vps[clickPos].input === _validationTests.getPlaceholder.call(inputmask, clickPos)) {
262                        if (clickPos < seekNext.call(inputmask, -1)) return !0;
263                        var radixPos = getBuffer.call(inputmask).indexOf(opts.radixPoint);
264                        if (-1 !== radixPos) {
265                            for (var vp in vps) if (vps[vp] && radixPos < vp && vps[vp].input !== _validationTests.getPlaceholder.call(inputmask, vp)) return !1;
266                            return !0;
267                        }
268                    }
269                }
270                return !1;
271            }
272            if (tabbed && (inputmask.isRTL ? selectedCaret.end = selectedCaret.begin : selectedCaret.begin = selectedCaret.end), 
273            selectedCaret.begin === selectedCaret.end) {
274                switch (opts.positionCaretOnClick) {
275                  case "none":
276                    break;
277
278                  case "select":
279                    selectedCaret = {
280                        begin: 0,
281                        end: getBuffer.call(inputmask).length
282                    };
283                    break;
284
285                  case "ignore":
286                    selectedCaret.end = selectedCaret.begin = seekNext.call(inputmask, getLastValidPosition.call(inputmask));
287                    break;
288
289                  case "radixFocus":
290                    if (doRadixFocus(selectedCaret.begin)) {
291                        var radixPos = getBuffer.call(inputmask).join("").indexOf(opts.radixPoint);
292                        selectedCaret.end = selectedCaret.begin = opts.numericInput ? seekNext.call(inputmask, radixPos) : radixPos;
293                        break;
294                    }
295
296                  default:
297                    var clickPosition = selectedCaret.begin, lvclickPosition = getLastValidPosition.call(inputmask, clickPosition, !0), lastPosition = seekNext.call(inputmask, -1 !== lvclickPosition || isMask.call(inputmask, 0) ? lvclickPosition : -1);
298                    if (clickPosition <= lastPosition) selectedCaret.end = selectedCaret.begin = isMask.call(inputmask, clickPosition, !1, !0) ? clickPosition : seekNext.call(inputmask, clickPosition); else {
299                        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);
300                        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) {
301                            var newPos = seekNext.call(inputmask, lastPosition);
302                            (newPos <= clickPosition || clickPosition === lastPosition) && (lastPosition = newPos);
303                        }
304                        selectedCaret.end = selectedCaret.begin = lastPosition;
305                    }
306                }
307                return selectedCaret;
308            }
309        }
310        function getBuffer(noCache) {
311            var inputmask = this, maskset = this.maskset;
312            return void 0 !== maskset.buffer && !0 !== noCache || (maskset.buffer = _validationTests.getMaskTemplate.call(this, !0, getLastValidPosition.call(this), !0), 
313            void 0 === maskset._buffer && (maskset._buffer = maskset.buffer.slice())), maskset.buffer;
314        }
315        function getBufferTemplate() {
316            var inputmask = this, maskset = this.maskset;
317            return void 0 === maskset._buffer && (maskset._buffer = _validationTests.getMaskTemplate.call(this, !1, 1), 
318            void 0 === maskset.buffer && (maskset.buffer = maskset._buffer.slice())), maskset._buffer;
319        }
320        function getLastValidPosition(closestTo, strict, validPositions) {
321            var maskset = this.maskset, before = -1, after = -1, valids = validPositions || maskset.validPositions;
322            for (var posNdx in void 0 === closestTo && (closestTo = -1), valids) {
323                var psNdx = parseInt(posNdx);
324                valids[psNdx] && (strict || !0 !== valids[psNdx].generatedInput) && (psNdx <= closestTo && (before = psNdx), 
325                closestTo <= psNdx && (after = psNdx));
326            }
327            return -1 === before || before == closestTo ? after : -1 == after ? before : closestTo - before < after - closestTo ? before : after;
328        }
329        function isMask(pos, strict, fuzzy) {
330            var inputmask = this, maskset = this.maskset, test = _validationTests.getTestTemplate.call(this, pos).match;
331            if ("" === test.def && (test = _validationTests.getTest.call(this, pos).match), 
332            !0 !== test.static) return test.fn;
333            if (!0 === fuzzy && void 0 !== maskset.validPositions[pos] && !0 !== maskset.validPositions[pos].generatedInput) return !0;
334            if (!0 !== strict && -1 < pos) {
335                if (fuzzy) {
336                    var tests = _validationTests.getTests.call(this, pos);
337                    return tests.length > 1 + ("" === tests[tests.length - 1].match.def ? 1 : 0);
338                }
339                var testTemplate = _validationTests.determineTestTemplate.call(this, pos, _validationTests.getTests.call(this, pos)), testPlaceHolder = _validationTests.getPlaceholder.call(this, pos, testTemplate.match);
340                return testTemplate.match.def !== testPlaceHolder;
341            }
342            return !1;
343        }
344        function resetMaskSet(soft) {
345            var maskset = this.maskset;
346            maskset.buffer = void 0, !0 !== soft && (maskset.validPositions = {}, maskset.p = 0);
347        }
348        function seekNext(pos, newBlock, fuzzy) {
349            var inputmask = this;
350            void 0 === fuzzy && (fuzzy = !0);
351            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++;
352            return position;
353        }
354        function seekPrevious(pos, newBlock) {
355            var inputmask = this, position = pos - 1;
356            if (pos <= 0) return 0;
357            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--;
358            return position;
359        }
360        function translatePosition(pos) {
361            var inputmask = this, opts = this.opts, el = this.el;
362            return !this.isRTL || "number" != typeof pos || opts.greedy && "" === opts.placeholder || !el || (pos = this._valueGet().length - pos), 
363            pos;
364        }
365    }, function(module, exports, __webpack_require__) {
366        "use strict";
367        function getLocator(tst, align) {
368            var locator = (null != tst.alternation ? tst.mloc[getDecisionTaker(tst)] : tst.locator).join("");
369            if ("" !== locator) for (;locator.length < align; ) locator += "0";
370            return locator;
371        }
372        function getDecisionTaker(tst) {
373            var decisionTaker = tst.locator[tst.alternation];
374            return "string" == typeof decisionTaker && 0 < decisionTaker.length && (decisionTaker = decisionTaker.split(",")[0]), 
375            void 0 !== decisionTaker ? decisionTaker.toString() : "";
376        }
377        function getPlaceholder(pos, test, returnPL) {
378            var inputmask = this, opts = this.opts, maskset = this.maskset;
379            if (test = test || getTest.call(this, pos).match, void 0 !== test.placeholder || !0 === returnPL) return "function" == typeof test.placeholder ? test.placeholder(opts) : test.placeholder;
380            if (!0 !== test.static) return opts.placeholder.charAt(pos % opts.placeholder.length);
381            if (-1 < pos && void 0 === maskset.validPositions[pos]) {
382                var tests = getTests.call(this, pos), staticAlternations = [], prevTest;
383                if (tests.length > 1 + ("" === tests[tests.length - 1].match.def ? 1 : 0)) for (var i = 0; i < tests.length; i++) if ("" !== tests[i].match.def && !0 !== tests[i].match.optionality && !0 !== tests[i].match.optionalQuantifier && (!0 === tests[i].match.static || void 0 === prevTest || !1 !== tests[i].match.fn.test(prevTest.match.def, maskset, pos, !0, opts)) && (staticAlternations.push(tests[i]), 
384                !0 === tests[i].match.static && (prevTest = tests[i]), 1 < staticAlternations.length && /[0-9a-bA-Z]/.test(staticAlternations[0].match.def))) return opts.placeholder.charAt(pos % opts.placeholder.length);
385            }
386            return test.def;
387        }
388        function getMaskTemplate(baseOnInput, minimalPos, includeMode, noJit, clearOptionalTail) {
389            var inputmask = this, opts = this.opts, maskset = this.maskset, greedy = opts.greedy;
390            clearOptionalTail && (opts.greedy = !1), minimalPos = minimalPos || 0;
391            var maskTemplate = [], ndxIntlzr, pos = 0, test, testPos, jitRenderStatic;
392            do {
393                if (!0 === baseOnInput && maskset.validPositions[pos]) testPos = clearOptionalTail && !0 === maskset.validPositions[pos].match.optionality && void 0 === maskset.validPositions[pos + 1] && (!0 === maskset.validPositions[pos].generatedInput || maskset.validPositions[pos].input == opts.skipOptionalPartCharacter && 0 < pos) ? determineTestTemplate.call(this, pos, getTests.call(this, pos, ndxIntlzr, pos - 1)) : maskset.validPositions[pos], 
394                test = testPos.match, ndxIntlzr = testPos.locator.slice(), maskTemplate.push(!0 === includeMode ? testPos.input : !1 === includeMode ? test.nativeD

452 i++) if ("-" === pattern.charAt(i)) for (end = pattern.charCodeAt(i + 1); ++start < end; ) expanded.push(String.fromCharCode(start)); else start = pattern.charCodeAt(i), 
453                            expanded.push(pattern.charAt(i));
454                            return expanded.join("");
455                        }
456                        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, "")));
457                    }
458                    function staticCanMatchDefinition(source, target) {
459                        return !0 === source.match.static && !0 !== target.match.static && target.match.fn.test(source.match.def, maskset, pos, !1, opts, !1);
460                    }
461                    function setMergeLocators(targetMatch, altMatch) {
462                        var alternationNdx = targetMatch.alternation, shouldMerge = void 0 === altMatch || alternationNdx === altMatch.alternation && -1 === targetMatch.locator[alternationNdx].toString().indexOf(altMatch.locator[alternationNdx]);
463                        if (!shouldMerge && alternationNdx > altMatch.alternation) for (var i = altMatch.alternation; i < alternationNdx; i++) if (targetMatch.locator[i] !== altMatch.locator[i]) {
464                            alternationNdx = i, shouldMerge = !0;
465                            break;
466                        }
467                        if (shouldMerge) {
468                            targetMatch.mloc = targetMatch.mloc || {};
469                            var locNdx = targetMatch.locator[alternationNdx];
470                            if (void 0 !== locNdx) {
471                                if ("string" == typeof locNdx && (locNdx = locNdx.split(",")[0]), void 0 === targetMatch.mloc[locNdx] && (targetMatch.mloc[locNdx] = targetMatch.locator.slice()), 
472                                void 0 !== altMatch) {
473                                    for (var ndx in altMatch.mloc) "string" == typeof ndx && (ndx = ndx.split(",")[0]), 
474                                    void 0 === targetMatch.mloc[ndx] && (targetMatch.mloc[ndx] = altMatch.mloc[ndx]);
475                                    targetMatch.locator[alternationNdx] = Object.keys(targetMatch.mloc).join(",");
476                                }
477                                return !0;
478                            }
479                            targetMatch.alternation = void 0;
480                        }
481                        return !1;
482                    }
483                    function isSameLevel(targetMatch, altMatch) {
484                        if (targetMatch.locator.length !== altMatch.locator.length) return !1;
485                        for (var locNdx = targetMatch.alternation + 1; locNdx < targetMatch.locator.length; locNdx++) if (targetMatch.locator[locNdx] !== altMatch.locator[locNdx]) return !1;
486                        return !0;
487                    }
488                    if (testPos > pos + opts._maxTestPos) throw "Inputmask: There is probably an error in your mask definition or in the code. Create an issue on github with an example of the mask you are using. " + maskset.mask;
489                    if (testPos === pos && void 0 === match.matches) return matches.push({
490                        match: match,
491                        locator: loopNdx.reverse(),
492                        cd: cacheDependency,
493                        mloc: {}
494                    }), !0;
495                    if (void 0 !== match.matches) {
496                        if (match.isGroup && quantifierRecurse !== match) {
497                            if (match = handleMatch(maskToken.matches[maskToken.matches.indexOf(match) + 1], loopNdx, quantifierRecurse), 
498                            match) return !0;
499                        } else if (match.isOptional) {
500                            var optionalToken = match, mtchsNdx = matches.length;
501                            if (match = resolveTestFromToken(match, ndxInitializer, loopNdx, quantifierRecurse), 
502                            match) {

750            strict = !0 === strict;
751            var maskPos = pos;
752            function processCommandObject(commandObj) {
753                if (void 0 !== commandObj) {
754                    if (void 0 !== commandObj.remove && (Array.isArray(commandObj.remove) || (commandObj.remove = [ commandObj.remove ]), 
755                    commandObj.remove.sort(function(a, b) {
756                        return b.pos - a.pos;
757                    }).forEach(function(lmnt) {
758                        revalidateMask.call(inputmask, {
759                            begin: lmnt,
760                            end: lmnt + 1
761                        });
762                    }), commandObj.remove = void 0), void 0 !== commandObj.insert && (Array.isArray(commandObj.insert) || (commandObj.insert = [ commandObj.insert ]), 
763                    commandObj.insert.sort(function(a, b) {
764                        return a.pos - b.pos;
765                    }).forEach(function(lmnt) {
766                        "" !== lmnt.c && isValid.call(inputmask, lmnt.pos, lmnt.c, void 0 === lmnt.strict || lmnt.strict, void 0 !== lmnt.fromIsValid ? lmnt.fromIsValid : fromIsValid);
767                    }), commandObj.insert = void 0), commandObj.refreshFromBuffer && commandObj.buffer) {
768                        var refresh = commandObj.refreshFromBuffer;
769                        refreshFromBuffer.call(inputmask, !0 === refresh ? refresh : refresh.start, refresh.end, commandObj.buffer), 
770                        commandObj.refreshFromBuffer = void 0;
771                    }
772                    void 0 !== commandObj.rewritePosition && (maskPos = commandObj.rewritePosition, 
773                    commandObj = !0);
774                }
775                return commandObj;
776            }
777            function _isValid(position, c, strict) {
778                var rslt = !1;
779                return _validationTests.getTests.call(inputmask, position).every(function(tst, ndx) {
780                    var test = tst.match;
781                    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 && {
782                        c: _validationTests.getPlaceholder.call(inputmask, position, test, !0) || test.def,
783                        pos: position
784                    }, !1 === rslt) return !0;
785                    var elem = void 0 !== rslt.c ? rslt.c : c, validatedPos = position;
786                    return elem = elem === opts.skipOptionalPartCharacter && !0 === test.static ? _validationTests.getPlaceholder.call(inputmask, position, test, !0) || test.def : elem, 
787                    rslt = processCommandObject(rslt), !0 !== rslt && void 0 !== rslt.pos && rslt.pos !== position && (validatedPos = rslt.pos), 
788                    !0 !== rslt && void 0 === rslt.pos && void 0 === rslt.c || !1 === revalidateMask.call(inputmask, pos, $.extend({}, tst, {
789                        input: casing.call(inputmask, elem, test, validatedPos)
790                    }), fromIsValid, validatedPos) && (rslt = !1), !1;
791                }), rslt;
792            }
793            void 0 !== pos.begin && (maskPos = inputmask.isRTL ? pos.end : pos.begin);
794            var result = !0, positionsClone = $.extend(!0, {}, maskset.validPositions);
795            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, 
796            delete maskset.tests[i]);
797            if ("function" == typeof opts.preValidation && !0 !== fromIsValid && !0 !== validateOnly && (result = opts.preValidation.call(el, _positioning.getBuffer.call(inputmask), maskPos, c, isSelection(pos), opts, maskset, pos, strict || fromAlternate), 
798            result = processCommandObject(result)), !0 === result) {
799                if (void 0 === inputmask.maxLength || maskPos < inputmask.maxLength) {
800                    if (result = _isValid(maskPos, c, strict), (!strict || !0 === fromIsValid) && !1 === result && !0 !== validateOnly) {
801                        var currentPosValid = maskset.validPositions[maskPos];
802                        if (!currentPosValid || !0 !== currentPosValid.match.static || currentPosValid.match.def !== c && c !== opts.skipOptionalPartCharacter) {
803                            if (opts.insertMode || void 0 === maskset.validPositions[_positioning.seekNext.call(inputmask, maskPos)] || pos.end > maskPos) {
804                                var skip = !1;
805                                if (maskset.jitOffset[maskPos] && void 0 === maskset.validPositions[_positioning.seekNext.call(inputmask, maskPos)] && (result = isValid.call(inputmask, maskPos + maskset.jitOffset[maskPos], c, !0), 
806                                !1 !== result && (!0 !== fromAlternate && (result.caret = maskPos), skip = !0)), 
807                                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), 
808                                !1 !== result) {
809                                    result = trackbackPositions.call(inputmask, maskPos, void 0 !== result.pos ? result.pos : nPos) || result, 
810                                    maskPos = nPos;
811                                    break;
812                                }
813                            }
814                        } else result = {
815                            caret: _positioning.seekNext.call(inputmask, maskPos)
816                        };
817                    }
818                } else result = !1;
819                !1 !== result || !opts.keepStatic || !isComplete.call(inputmask, _positioning.getBuffer.call(inputmask)) && 0 !== maskPos || str

997            opts.skipOptionalPartCharacter = skipOptionalPartCharacter;
998        }
999        function HandleNativePlaceholder(npt, value) {
1000            var inputmask = npt ? npt.inputmask : this;
1001            if (_environment.ie) {
1002                if (npt.inputmask._valueGet() !== value && (npt.placeholder !== value || "" === npt.placeholder)) {
1003                    var buffer = _positioning.getBuffer.call(inputmask).slice(), nptValue = npt.inputmask._valueGet();
1004                    if (nptValue !== value) {
1005                        var lvp = _positioning.getLastValidPosition.call(inputmask);
1006                        -1 === lvp && nptValue === _positioning.getBufferTemplate.call(inputmask).join("") ? buffer = [] : -1 !== lvp && clearOptionalTail.call(inputmask, buffer), 
1007                        writeBuffer(npt, buffer);
1008                    }
1009                }
1010            } else npt.placeholder !== value && (npt.placeholder = value, "" === npt.placeholder && npt.removeAttribute("placeholder"));
1011        }
1012        function unmaskedvalue(input) {
1013            var inputmask = input ? input.inputmask : this, opts = inputmask.opts, maskset = inputmask.maskset;
1014            if (input) {
1015                if (void 0 === input.inputmask) return input.value;
1016                input.inputmask && input.inputmask.refreshValue && applyInputValue(input, input.inputmask._valueGet(!0));
1017            }
1018            var umValue = [], vps = maskset.validPositions;
1019            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);
1020            var unmaskedValue = 0 === umValue.length ? "" : (inputmask.isRTL ? umValue.reverse() : umValue).join("");
1021            if ("function" == typeof opts.onUnMask) {
1022                var bufferValue = (inputmask.isRTL ? _positioning.getBuffer.call(inputmask).slice().reverse() : _positioning.getBuffer.call(inputmask)).join("");
1023                unmaskedValue = opts.onUnMask.call(inputmask, bufferValue, unmaskedValue, opts);
1024            }
1025            return unmaskedValue;
1026        }
1027        function writeBuffer(input, buffer, caretPos, event, triggerEvents) {
1028            var inputmask = input ? input.inputmask : this, opts = inputmask.opts, $ = inputmask.dependencyLib;
1029            if (event && "function" == typeof opts.onBeforeWrite) {
1030                var result = opts.onBeforeWrite.call(inputmask, event, buffer, caretPos, opts);
1031                if (result) {
1032                    if (result.refreshFromBuffer) {
1033                        var refresh = result.refreshFromBuffer;
1034                        _validation.refreshFromBuffer.call(inputmask, !0 === refresh ? refresh : refresh.start, refresh.end, result.buffer || buffer), 
1035                        buffer = _positioning.getBuffer.call(inputmask, !0);
1036                    }
1037                    void 0 !== caretPos && (caretPos = void 0 !== result.caret ? result.caret : caretPos);
1038                }
1039            }
1040            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)), 
1041            !0 === triggerEvents)) {
1042                var $input = $(input), nptVal = input.inputmask._valueGet();
1043                input.inputmask.skipInputEvent = !0, $input.trigger("input"), setTimeout(function() {
1044                    nptVal === _positioning.getBufferTemplate.call(inputmask).join("") ? $input.trigger("cleared") : !0 === _validation.isComplete.call(inputmask, buffer) && $input.trigger("complete");
1045                }, 0);
1046            }
1047        }
1048    }, function(module, exports, __webpack_require__) {
1049        "use strict";
1050        Object.defineProperty(exports, "__esModule", {
1051            value: !0
1052        }), exports.EventHandlers = void 0;
1053        var _positioning = __webpack_require__(2), _keycode = _interopRequireDefault(__webpack_require__(0)), _environment = __webpack_require__(7), _validation = __webpack_require__(4), _inputHandling = __webpack_require__(5), _validationTests = __webpack_require__(3);
1054        function _interopRequireDefault(obj) {
1055            return obj && obj.__esModule ? obj : {
1056                default: obj
1057            };
1058        }
1059        var EventHandlers = {
1060            keydownEvent: function keydownEvent(e) {
1061                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);
1062                if (void 0 !== kdResult) return kdResult;
1063                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(), 
1064                _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) {
1065                    e.preventDefault();
1066                    var caretPos = _positioning.seekNext.call(inputmask, _positioning.getLastValidPosition.call(inputmask));
1067                    _positioning.caret.call(inputmask, input, e.shiftKey ? pos.begin : caretPos, caretPos, !0);
1068                } else k === _keycode.default.HOME && !e.shiftKey || k === _keycode.default.PAGE_UP ? (e.preventDefault(), 
1069                _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, 
1070                _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), 
1071                !0 === _validationTests.getTest.call(inputmask, pos.end - 1).match.static && pos.end--, 
1072                pos.begin = _positioning.seekPrevious.call(inputmask, pos.end, !0), 0 <= pos.begin && 0 < pos.end && (e.preventDefault(), 
1073                _positioning.caret.call(inputmask, input, pos.begin, pos.end))) : (pos.begin = _positioning.seekNext.call(inputmask, pos.begin, !0), 
1074                pos.end = _positioning.seekNext.call(inputmask, pos.begin, !0), pos.end < maskset.maskLength && pos.end--, 
1075                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() {
1076                    var caretPos = _positioning.caret.call(inputmask, input);
1077                    _positioning.caret.call(inputmask, input, caretPos.begin);
1078                }, 0) : k === _keycode.default.LEFT && setTimeout(function() {
1079                    var caretPos_begin = _positioning.translatePosition.call(inputmask, input.inputmask.caretPos.begin), caretPos_end = _positioning.translatePosition.call(inputmask, input.inputmask.caretPos.end);
1080                    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));
1081                }, 0));
1082                inputmask.ignorable = opts.ignorables.includes(k);
1083            },
1084            keypressEvent: function keypressEvent(e, checkval, writeOut, strict, ndx) {
1085                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;
1086                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(""), 
1087                setTimeout(function() {
1088                    $input.trigger("change");
1089                }, 0)), inputmask.skipInputEvent = !0, !0;
1090                if (k) {
1091                    44 !== k && 46 !== k || 3 !== e.location || "" === opts.radixPoint || (k = opts.radixPoint.charCodeAt(0));
1092                    var pos = checkval ? {
1093                        begin: ndx,
1094                        end: ndx
1095                    } : _positioning.caret.call(inputmask, input), forwardPosition, c = String.fromCharCode(k);
1096                    maskset.writeOutBuffer = !0;
1097                    var valResult = _validation.isValid.call(inputmask, pos, c, strict, void 0, void 0, void 0, checkval);
1098                    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), 
1099                    maskset.p = forwardPosition), forwardPosition = opts.numericInput && void 0 === valResult.caret ? _positioning.seekPrevious.call(inputmask, forwardPosition) : forwardPosition, 
1100                    !1 !== writeOut && (setTimeout(function() {
1101                        opts.onKeyValidation.call(input, k, valResult);
1102                    }, 0), maskset.writeOutBuffer && !1 !== valResult)) {
1103                        var buffer = _positioning.getBuffer.call(inputmask);
1104                        (0, _inputHandling.writeBuffer)(input, buffer, forwardPosition, e, !0 !== checkval);
1105                    }
1106                    if (e.preventDefault(), checkval) return !1 !== valResult && (valResult.forwardPosition = forwardPosition), 
1107                    valResult;
1108                }
1109            },
1110            keyupEvent: function keyupEvent(e) {
1111                var inputmask = this.inputmask;
1112                !inputmask.isComposing || e.keyCode !== _keycode.default.KEY_229 && e.keyCode !== _keycode.default.ENTER || inputmask.$el.trigger("input");
1113            },
1114            pasteEvent: function pasteEvent(e) {
1115                var inputmask = this.inputmask, opts = inputmask.opts, input = this, inputValue = inputmask._valueGet(!0), caretPos = _positioning.caret.call(inputmask, this), tempValue;
1116                inputmask.isRTL && (tempValue = caretPos.end, caretPos.end = caretPos.begin, caretPos.begin = tempValue);
1117                var valueBeforeCaret = inputValue.substr(0, caretPos.begin), valueAfterCaret = inputValue.substr(caretPos.end, inputValue.length);
1118                if (valueBeforeCaret == (inputmask.isRTL ? _positioning.getBufferTemplate.call(inputmask).slice().reverse() : _positioning.getBufferTemplate.call(inputmask)).slice(0, caretPos.begin).join("") && (valueBeforeCaret = ""), 
1119                valueAfterCaret == (inputmask.isRTL ? _positioning.getBufferTemplate.call(inputmask).slice().reverse() : _positioning.getBufferTemplate.call(inputmask)).slice(caretPos.end).join("") && (valueAfterCaret = ""), 
1120                window.clipboardData && window.clipboardData.getData) inputValue = valueBeforeCaret + window.clipboardData.getData("Text") + valueAfterCaret; else {
1121                    if (!e.clipboardData || !e.clipboardData.getData) return !0;
1122                    inputValue = valueBeforeCaret + e.clipboardData.getData("text/plain") + valueAfterCaret;
1123                }
1124                var pasteValue = inputValue;
1125                if ("function" == typeof opts.onBeforePaste) {
1126                    if (pasteValue = opts.onBeforePaste.call(inputmask, inputValue, opts), !1 === pasteValue) return e.preventDefault();
1127                    pasteValue = pasteValue || inputValue;
1128                }
1129                return (0, _inputHandling.checkVal)(this, !0, !1, pasteValue.toString().split(""), e), 
1130                e.preventDefault();
1131            },
1132            inputFallBackEvent: function inputFallBackEvent(e) {
1133                var inputmask = this.inputmask, opts = inputmask.opts, $ = inputmask.dependencyLib;
1134                function ieMobileHandler(input, inputValue, caretPos) {
1135                    if (_environment.iemobile) {
1136                        var inputChar = inputValue.replace(_positioning.getBuffer.call(inputmask).join(""), "");
1137                        if (1 === inputChar.length) {
1138                            var iv = inputValue.split("");
1139                            iv.splice(caretPos.begin, 0, inputChar), inputValue = iv.join("");
1140                        }
1141                    }
1142                    return inputValue;
1143                }
1144                function analyseChanges(inputValue, buffer, caretPos) {
1145                    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;

1406opts.showMaskOnFocus = opts.showMaskOnFocus && -1 === [ "cc-number", "cc-exp" ].indexOf(el.autocomplete), 
1407                _environment.iphone && (opts.insertModeVisual = !1), _eventruler.EventRuler.on(el, "submit", _eventhandlers.EventHandlers.submitEvent), 
1408                _eventruler.EventRuler.on(el, "reset", _eventhandlers.EventHandlers.resetEvent), 
1409                _eventruler.EventRuler.on(el, "blur", _eventhandlers.EventHandlers.blurEvent), _eventruler.EventRuler.on(el, "focus", _eventhandlers.EventHandlers.focusEvent), 
1410                _eventruler.EventRuler.on(el, "invalid", _eventhandlers.EventHandlers.invalidEvent), 
1411                _eventruler.EventRuler.on(el, "click", _eventhandlers.EventHandlers.clickEvent), 
1412                _eventruler.EventRuler.on(el, "mouseleave", _eventhandlers.EventHandlers.mouseleaveEvent), 
1413                _eventruler.EventRuler.on(el, "mouseenter", _eventhandlers.EventHandlers.mouseenterEvent), 
1414                _eventruler.EventRuler.on(el, "paste", _eventhandlers.EventHandlers.pasteEvent), 
1415                _eventruler.EventRuler.on(el, "cut", _eventhandlers.EventHandlers.cutEvent), _eventruler.EventRuler.on(el, "complete", opts.oncomplete), 
1416                _eventruler.EventRuler.on(el, "incomplete", opts.onincomplete), _eventruler.EventRuler.on(el, "cleared", opts.oncleared), 
1417                !0 !== opts.inputEventOnly && (_eventruler.EventRuler.on(el, "keydown", _eventhandlers.EventHandlers.keydownEvent), 
1418                _eventruler.EventRuler.on(el, "keypress", _eventhandlers.EventHandlers.keypressEvent), 
1419                _eventruler.EventRuler.on(el, "keyup", _eventhandlers.EventHandlers.keyupEvent)), 
1420                (_environment.mobile || opts.inputEventOnly) && el.removeAttribute("maxLength"), 
1421                _eventruler.EventRuler.on(el, "input", _eventhandlers.EventHandlers.inputFallBackEvent), 
1422                _eventruler.EventRuler.on(el, "compositionend", _eventhandlers.EventHandlers.compositionendEvent)), 
1423                _eventruler.EventRuler.on(el, "setvalue", _eventhandlers.EventHandlers.setValueEvent), 
1424                inputmask.undoValue = _positioning.getBufferTemplate.call(inputmask).join("");
1425                var activeElement = (el.inputmask.shadowRoot || document).activeElement;
1426                if ("" !== el.inputmask._valueGet(!0) || !1 === opts.clearMaskOnLostFocus || activeElement === el) {
1427                    (0, _inputHandling.applyInputValue)(el, el.inputmask._valueGet(!0), opts);
1428                    var buffer = _positioning.getBuffer.call(inputmask).slice();
1429                    !1 === _validation.isComplete.call(inputmask, buffer) && opts.clearIncomplete && _positioning.resetMaskSet.call(inputmask), 
1430                    opts.clearMaskOnLostFocus && activeElement !== el && (-1 === _positioning.getLastValidPosition.call(inputmask) ? buffer = [] : _inputHandling.clearOptionalTail.call(inputmask, buffer)), 
1431                    (!1 === opts.clearMaskOnLostFocus || opts.showMaskOnFocus && activeElement === el || "" !== el.inputmask._valueGet(!0)) && (0, 
1432                    _inputHandling.writeBuffer)(el, buffer), activeElement === el && _positioning.caret.call(inputmask, el, _positioning.seekNext.call(inputmask, _positioning.getLastValidPosition.call(inputmask)));
1433                }
1434            }
1435        }
1436    }, function(module, exports, __webpack_require__) {
1437        "use strict";
1438        Object.defineProperty(exports, "__esModule", {
1439            value: !0
1440        }), exports.EventRuler = void 0;
1441        var _inputmask = _interopRequireDefault(__webpack_require__(1)), _keycode = _interopRequireDefault(__webpack_require__(0)), _positioning = __webpack_require__(2), _inputHandling = __webpack_require__(5);
1442        function _interopRequireDefault(obj) {
1443            return obj && obj.__esModule ? obj : {
1444                default: obj
1445            };
1446        }
1447        var EventRuler = {
1448            on: function on(input, eventName, eventHandler) {
1449                var $ = input.inputmask.dependencyLib, ev = function ev(e) {
1450                    e.originalEvent && (e = e.originalEvent || e, arguments[0] = e);
1451                    var that = this, args, inputmask = that.inputmask, opts = inputmask ? inputmask.opts : void 0, $ = inputmask.dependencyLib;
1452                    if (void 0 === inputmask && "FORM" !== this.nodeName) {
1453                        var imOpts = $.data(that, "_inputmask_opts");
1454                        $(that).off(), imOpts && new _inputmask.default(imOpts).mask(that);
1455                    } else {
1456                        if ("setvalue" === 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))) {
1457                            switch (e.type) {
1458                              case "input":
1459                                if (!0 === inputmask.skipInputEvent || e.inputType && "insertCompositionText" === e.inputType) return inputmask.skipInputEvent = !1, 
1460                                e.preventDefault();
1461                                break;
1462
1463                              case "keydown":
1464                                inputmask.skipKeyPressEvent = !1, inputmask.skipInputEvent = inputmask.isComposing = e.keyCode === _keycode.default.KEY_229;
1465                                break;
1466
1467                              case "keyup":
1468                              case "compositionend":
1469                                inputmask.isComposing && (inputmask.skipInputEvent = !1);
1470                                break;
1471
1472                              case "keypress":
1473                                if (!0 === inputmask.skipKeyPressEvent) return e.preventDefault();
1474                                inputmask.skipKeyPressEvent = !0;
1475                                break;
1476
1477                              case "click":
1478                              case "focus":
1479                                return inputmask.validationEvent ? (inputmask.validationEvent = !1, input.blur(), 
1480                                (0, _inputHandling.HandleNativePlaceholder)(input, (inputmask.isRTL ? _positioning.getBufferTemplate.call(inputmask).slice().reverse() : _positioning.getBufferTemplate.call(inputmask)).join("")), 
1481                                setTimeout(function() {
1482                                    input.focus();
1483                                }, 3e3)) : (args = arguments, setTimeout(function() {
1484                                    input.inputmask && eventHandler.apply(that, args);
1485                                }, 0)), !1;
1486                            }
1487                            var returnVal = eventHandler.apply(that, arguments);
1488                            return !1 === returnVal && (e.preventDefault(), e.stopPropagation()), returnVal;
1489                        }
1490                        e.preventDefault();
1491                    }
1492                };
1493                input.inputmask.events[eventName] = input.inputmask.events[eventName] || [], input.inputmask.events[eventName].push(ev), 
1494                [ "submit", "reset" ].includes(eventName) ? null !== input.form && $(input.form).on(eventName, ev.bind(input)) : $(input).on(eventName, ev);
1495            },
1496            off: function off(input, event) {
1497                if (input.inputmask && input.inputmask.events) {
1498                    var $ = input.inputmask.dependencyLib, events = input.inputmask.events;
1499                    for (var eventName in event && (events = [], events[event] = input.inputmask.events[event]), 
1500                    events) {
1501                        for (var evArr = events[eventName]; 0 < evArr.length; ) {
1502                            var ev = evArr.pop();
1503                            [ "submit", "reset" ].includes(eventName) ? null !== input.form && $(input.form).off(eventName, ev) : $(input).off(eventName, ev);
1504                        }
1505                        delete input.inputmask.events[eventName];
1506                    }
1507                }
1508            }
1509        };
1510        exports.EventRuler = EventRuler;
1511    }, function(module, exports, __webpack_require__) {
1512        "use strict";
1513        Object.defineProperty(exports, "__esModule", {
1514            value: !0
1515        }), exports.default = void 0;
1516        var _jquery = _interopRequireDefault(__webpack_require__(8));
1517        function _interopRequireDefault(obj) {
1518            return obj && obj.__esModule ? obj : {
1519                default: obj
1520            };
1521        }
1522        if (void 0 === _jquery.default) throw "jQuery not loaded!";
1523        var _default = _jquery.default;
1524        exports.default = _default;
1525    }, function(module, exports, __webpack_require__) {
1526        "use strict";
1527        Object.defineProperty(exports, "__esModule", {
1528            value: !0
1529        }), exports.default = void 0;
1530        var _default = "undefined" != typeof window ? window : new (eval("require('jsdom').JSDOM"))("").window;
1531        exports.default = _default;
1532    }, function(module, exports, __webpack_require__) {
1533        "use strict";
1534        Object.defineProperty(exports, "__esModule", {
1535            value: !0
1536        }), exports.default = _default;
1537        var escapeRegexRegex = new RegExp("(\\" + [ "/", ".", "*", "+", "?", "|", "(", ")", "[", "]", "{", "}", "\\", "$", "^" ].join("|\\") + ")", "gim");
1538        function _default(str) {
1539            return str.replace(escapeRegexRegex, "\\$1");
1540        }
1541    }, function(module, exports, __webpack_require__) {
1542        "use strict";
1543        Object.defineProperty(exports, "__esModule", {
1544            value: !0
1545        }), exports.default = void 0, __webpack_require__(16), __webpack_require__(20), 
1546        __webpack_require__(21), __webpack_require__(22);
1547        var _default = "./lib/inputmask.js";
1548        exports.default = _default;
1549    }, function(module, exports, __webpack_require__) {
1550        "use strict";
1551        var _inputmask = _interopRequireDefault(__webpack_require__(1));
1552        function _interopRequireDefault(obj) {
1553            return obj && obj.__esModule ? obj : {
1554                default: obj
1555            };
1556        }
1557        _inputmask.default.extendDefinitions({
1558            A: {
1559                validator: "[A-Za-z\u0410-\u044f\u0401\u0451\xc0-\xff\xb5]",
1560                casing: "upper"
1561            },
1562            "&": {
1563                validator: "[0-9A-Za-z\u0410-\u044f\u0401\u0451\xc0-\xff\xb5]",
1564                casing: "upper"
1565            },
1566            "#": {
1567                validator: "[0-9A-Fa-f]",
1568                casing: "upper"
1569            }
1570        });
1571        var ipValidatorRegex = new RegExp("25[0-5]|2[0-4][0-9]|[01][0-9][0-9]");
1572        function ipValidator(chrs, maskset, pos, strict, opts) {

1673                    maskToken: Inputmask.prototype.analyseMask(mask, regexMask, opts),
1674                    validPositions: {},
1675                    _buffer: void 0,
1676                    buffer: void 0,
1677                    tests: {},
1678                    excludes: {},
1679                    metadata: metadata,
1680                    maskLength: void 0,
1681                    jitOffset: {}
1682                }, !0 !== nocache && (Inputmask.prototype.masksCache[maskdefKey] = masksetDefinition, 
1683                masksetDefinition = _inputmask.default.extend(!0, {}, Inputmask.prototype.masksCache[maskdefKey]))) : masksetDefinition = _inputmask.default.extend(!0, {}, Inputmask.prototype.masksCache[maskdefKey]), 
1684                masksetDefinition;
1685            }
1686            if ("function" == typeof opts.mask && (opts.mask = opts.mask(opts)), Array.isArray(opts.mask)) {
1687                if (1 < opts.mask.length) {
1688                    null === opts.keepStatic && (opts.keepStatic = !0);
1689                    var altMask = opts.groupmarker[0];
1690                    return (opts.isRTL ? opts.mask.reverse() : opts.mask).forEach(function(msk) {
1691                        1 < altMask.length && (altMask += opts.groupmarker[1] + opts.alternatormarker + opts.groupmarker[0]), 
1692                        void 0 !== msk.mask && "function" != typeof msk.mask ? altMask += msk.mask : altMask += msk;
1693                    }), altMask += opts.groupmarker[1], generateMask(altMask, opts.mask, opts);
1694                }
1695                opts.mask = opts.mask.pop();
1696            }
1697            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), 
1698            ms;
1699        }
1700        function analyseMask(mask, regexMask, opts) {
1701            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(), match, m, openenings = [], maskTokens = [], openingToken, currentOpeningToken, alternator, lastMatch, closeRegexGroup = !1;
1702            function MaskToken(isGroup, isOptional, isQuantifier, isAlternator) {
1703                this.matches = [], this.openGroup = isGroup || !1, this.alternatorGroup = !1, this.isGroup = isGroup || !1, 
1704                this.isOptional = isOptional || !1, this.isQuantifier = isQuantifier || !1, this.isAlternator = isAlternator || !1, 
1705                this.quantifier = {
1706                    min: 1,
1707                    max: 1
1708                };
1709            }
1710            function insertTestDefinition(mtoken, element, position) {
1711                position = void 0 !== position ? position : mtoken.matches.length;
1712                var prevMatch = mtoken.matches[position - 1];
1713                if (regexMask) 0 === element.indexOf("[") || escaped && /\\d|\\s|\\w]/i.test(element) || "." === element ? mtoken.matches.splice(position++, 0, {
1714                    fn: new RegExp(element, opts.casing ? "i" : ""),
1715                    static: !1,
1716                    optionality: !1,
1717                    newBlockMarker: void 0 === prevMatch ? "master" : prevMatch.def !== element,
1718                    casing: null,
1719                    def: element,
1720                    placeholder: void 0,
1721                    nativeDef: element
1722                }) : (escaped && (element = element[element.length - 1]), element.split("").forEach(function(lmnt, ndx) {
1723                    prevMatch = mtoken.matches[position - 1], mtoken.matches.splice(position++, 0, {
1724                        fn: /[a-z]/i.test(opts.staticDefinitionSymbol || lmnt) ? new RegExp("[" + (opts.staticDefinitionSymbol || lmnt) + "]", opts.casing ? "i" : "") : null,
1725                        static: !0,
1726                        optionality: !1,
1727                        newBlockMarker: void 0 === prevMatch ? "master" : prevMatch.def !== lmnt && !0 !== prevMatch.static,
1728                        casing: null,
1729                        def: opts.staticDefinitionSymbol || lmnt,
1730                        placeholder: void 0 !== opts.staticDefinitionSymbol ? lmnt : void 0,
1731                        nativeDef: (escaped ? "'" : "") + lmnt
1732                    });
1733                })), escaped = !1; else {
1734                    var maskdef = opts.definitions && opts.definitions[element] || opts.usePrototypeDefinitions && Inputmask.prototype.definitions[element];
1735                    maskdef && !escaped ? mtoken.matches.splice(position++, 0, {
1736                        fn: maskdef.validator ? "string" == typeof maskdef.validator ? new RegExp(maskdef.validator, opts.casing ? "i" : "") : new function() {
1737                            this.test = maskdef.validator;
1738                        }() : new RegExp("."),
1739                        static: maskdef.static || !1,
1740                        optionality: !1,
1741                        newBlockMarker: void 0 === prevMatch ? "master" : prevMatch.def !== (maskdef.definitionSymbol || element),
1742                        casing: maskdef.casing,
1743                        def: maskdef.definitionSymbol || element,
1744                        placeholder: maskdef.placeholder,
1745                        nativeDef: element,
1746                        generated: maskdef.generated
1747                    }) : (mtoken.matches.splice(position++, 0, {
1748                        fn: /[a-z]/i.test(opts.staticDefinitionSymbol || element) ? new RegExp("[" + (opts.staticDefinitionSymbol || element) + "]", opts.casing ? "i" : "") : null,
1749                        static: !0,
1750                        optionality: !1,
1751                        newBlockMarker: void 0 === prevMatch ? "master" : prevMatch.def !== element && !0 !== prevMatch.static,
1752                        casing: null,
1753                        def: opts.staticDefinitionSymbol || element,
1754                        placeholder: void 0 !== opts.staticDefinitionSymbol ? element : void 0,
1755                        nativeDef: (escaped ? "'" : "") + element
1756                    }), escaped = !1);
1757                }
1758            }
1759            function verifyGroupMarker(maskToken) {
1760                maskToken && maskToken.matches && maskToken.matches.forEac

2004        var $ = _inputmask.default.dependencyLib, currentYear = new Date().getFullYear(), formatCode = {
2005            d: [ "[1-9]|[12][0-9]|3[01]", Date.prototype.setDate, "day", Date.prototype.getDate ],
2006            dd: [ "0[1-9]|[12][0-9]|3[01]", Date.prototype.setDate, "day", function() {
2007                return pad(Date.prototype.getDate.call(this), 2);
2008            } ],
2009            ddd: [ "" ],
2010            dddd: [ "" ],
2011            m: [ "[1-9]|1[012]", Date.prototype.setMonth, "month", function() {
2012                return Date.prototype.getMonth.call(this) + 1;
2013            } ],
2014            mm: [ "0[1-9]|1[012]", Date.prototype.setMonth, "month", function() {
2015                return pad(Date.prototype.getMonth.call(this) + 1, 2);
2016            } ],
2017            mmm: [ "" ],
2018            mmmm: [ "" ],
2019            yy: [ "[0-9]{2}", Date.prototype.setFullYear, "year", function() {
2020                return pad(Date.prototype.getFullYear.call(this), 2);
2021            } ],
2022            yyyy: [ "[0-9]{4}", Date.prototype.setFullYear, "year", function() {
2023                return pad(Date.prototype.getFullYear.call(this), 4);
2024            } ],
2025            h: [ "[1-9]|1[0-2]", Date.prototype.setHours, "hours", Date.prototype.getHours ],
2026            hh: [ "0[1-9]|1[0-2]", Date.prototype.setHours, "hours", function() {
2027                return pad(Date.prototype.getHours.call(this), 2);
2028            } ],
2029            hx: [ function(x) {
2030                return "[0-9]{".concat(x, "}");
2031            }, Date.prototype.setHours, "hours", function(x) {
2032                return Date.prototype.getHours;
2033            } ],
2034            H: [ "1?[0-9]|2[0-3]", Date.prototype.setHours, "hours", Date.prototype.getHours ],
2035            HH: [ "0[0-9]|1[0-9]|2[0-3]", Date.prototype.setHours, "hours", function() {
2036                return pad(Date.prototype.getHours.call(this), 2);
2037            } ],
2038            Hx: [ function(x) {
2039                return "[0-9]{".concat(x, "}");
2040            }, Date.prototype.setHours, "hours", function(x) {
2041                return function() {
2042                    return pad(Date.prototype.getHours.call(this), x);
2043                };
2044            } ],
2045            M: [ "[1-5]?[0-9]", Date.prototype.setMinutes, "minutes", Date.prototype.getMinutes ],
2046            MM: [ "0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]", Date.prototype.setMinutes, "minutes", function() {
2047                return pad(Date.prototype.getMinutes.call(this), 2);
2048            } ],
2049            s: [ "[1-5]?[0-9]", Date.prototype.setSeconds, "seconds", Date.prototype.getSeconds ],
2050            ss: [ "0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]", Date.prototype.setSeconds, "seconds", function() {
2051                return pad(Date.prototype.getSeconds.call(this), 2);
2052            } ],
2053            l: [ "[0-9]{3}", Date.prototype.setMilliseconds, "milliseconds", function() {
2054                return pad(Date.prototype.getMilliseconds.call(this), 3);
2055            } ],
2056            L: [ "[0-9]{2}", Date.prototype.setMilliseconds, "milliseconds", function() {
2057                return pad(Date.prototype.getMilliseconds.call(this), 2);
2058            } ],
2059            t: [ "[ap]" ],
2060            tt: [ "[ap]m" ],
2061            T: [ "[AP]" ],
2062            TT: [ "[AP]M" ],
2063            Z: [ "" ],
2064            o: [ "" ],
2065            S: [ "" ]
2066        }, formatAlias = {
2067            isoDate: "yyyy-mm-dd",
2068            isoTime: "HH:MM:ss",
2069            isoDateTime: "yyyy-mm-dd'T'HH:MM:ss",
2070            isoUtcDateTime: "UTC:yyyy-mm-dd'T'HH:MM:ss'Z'"
2071        };
2072        function formatcode(match) {
2073            var dynMatches = new RegExp("\\d+$").exec(match[0]);
2074            if (dynMatches && void 0 !== dynMatches[0]) {
2075                var fcode = formatCode[match[0][0] + "x"].slice("");
2076                return fcode[0] = fcode[0](dynMatches[0]), fcode[3] = fcode[3](dynMatches[0]), fcode;
2077            }
2078            if (formatCode[match[0]]) return formatCode[match[0]];
2079        }
2080        function getTokenizer(opts) {
2081            if (!opts.tokenizer) {
2082                var tokens = [], dyntokens = [];
2083                for (var ndx in formatCode) if (/\.*x$/.test(ndx)) {
2084                    var dynToken = ndx[0] + "\\d+";
2085                    -1 === dyntokens.indexOf(dynToken) && dyntokens.push(dynToken);
2086                } else -1 === tokens.indexOf(ndx[0]) && tokens.push(ndx[0]);
2087                opts.tokenizer = "(" + (0 < dyntokens.length ? dyntokens.join("|") + "|" : "") + tokens.join("+|") + ")+?|.", 
2088                opts.tokenizer = new RegExp(opts.tokenizer, "g");
2089            }
2090            return opts.tokenizer;
2091        }
2092        function prefillYear(dateParts, currentResult, opts) {
2093            if (dateParts.year !== dateParts.rawyear) {
2094                var crrntyear = currentYear.toString(), enteredPart = dateParts.rawyear.replace(/[^0-9]/g, ""), currentYearPart = crrntyear.slice(0, enteredPart.length), currentYearNextPart = crrntyear.slice(enteredPart.length);
2095                if (2 === enteredPart.length && enteredPart === currentYearPart) {
2096                    var entryCurrentYear = new Date(currentYear, dateParts.month - 1, dateParts.day);
2097                    dateParts.day == entryCurrentYear.getDate() && (!opts.max || opts.max.date.getTime() >= entryCurrentYear.getTime()) && (dateParts.date.setFullYear(currentYear), 
2098                    dateParts.year = crrntyear, currentResult.insert = [ {
2099                        pos: currentResult.pos + 1,
2100                        c: currentYearNextPart[0]
2101                    }, {
2102                        pos: currentResult.pos + 2,
2103                        c: currentYearNextPart[1]
2104                    } ]);
2105                }
2106            }
2107            return currentResult;
2108        }
2109        function isValidDate(dateParts, currentResult, opts) {
2110            if (!isFinite(dateParts.rawday) || "29" == dateParts.day && !isFinite(dateParts.rawyear) || new Date(dateParts.date.getFullYear(), isFinite(dateParts.rawmonth) ? dateParts.month : dateParts.date.getMonth() + 1, 0).getDate() >= dateParts.day) return currentResult;
2111            if ("29" == dateParts.day) {
2112                var tokenMatch = getTokenMatch(currentResult.pos, opts);
2113                if ("yyyy" === tokenMatch.targetMatch[0] && currentResult.pos - tokenMatch.targetMatchIndex == 2) return currentResult.remove = currentResult.pos + 1, 
2114                currentResult;
2115            }
2116            return !1;
2117        }
2118        function isDateInRange(dateParts, result, opts, maskset, fromCheckval) {
2119            if (!result) return result;
2120            if (opts.min) {
2121                if (dateParts.rawyear) {
2122                    var rawYear = dateParts.rawyear.replace(/[^0-9]/g, ""), minYear = opts.min.year.substr(0, rawYear.length), maxYear;
2123                    if (rawYear < minYear) {
2124                        var tokenMatch = getTokenMatch(result.pos, opts);
2125                        if (rawYear = dateParts.rawyear.substr(0, result.pos - tokenMatch.targetMatchIndex + 1), 
2126                        minYear = opts.min.year.substr(0, rawYear.length), minYear <= rawYear) return result.remove = tokenMatch.targetMatchIndex + rawYear.length, 
2127                        result;
2128                        if (rawYear = "yyyy" === tokenMatch.targetMatch[0] ? dateParts.rawyear.substr(1, 1) : dateParts.rawyear.substr(0, 1), 
2129                        minYear = opts.min.year.substr(2, 1), maxYear = opts.max ? opts.max.year.substr(2, 1) : rawYear, 
2130                        1 === rawYear.length && minYear <= rawYear <= maxYear && !0 !== fromCheckval) return "yyyy" === tokenMatch.targetMatch[0] ? (result.insert = [ {
2131                            pos: result.pos + 1,
2132                            c: rawYear,

2214                nextMatch: match,
2215                targetMatch: targetMatch
2216            };
2217        }
2218        _inputmask.default.extendAliases({
2219            datetime: {
2220                mask: function mask(opts) {
2221                    return opts.numericInput = !1, formatCode.S = opts.i18n.ordinalSuffix.join("|"), 
2222                    opts.inputFormat = formatAlias[opts.inputFormat] || opts.inputFormat, opts.displayFormat = formatAlias[opts.displayFormat] || opts.displayFormat || opts.inputFormat, 
2223                    opts.outputFormat = formatAlias[opts.outputFormat] || opts.outputFormat || opts.inputFormat, 
2224                    opts.placeholder = "" !== opts.placeholder ? opts.placeholder : opts.inputFormat.replace(/[[\]]/, ""), 
2225                    opts.regex = parse(opts.inputFormat, void 0, opts), opts.min = analyseMask(opts.min, opts.inputFormat, opts), 
2226                    opts.max = analyseMask(opts.max, opts.inputFormat, opts), null;
2227                },
2228                placeholder: "",
2229                inputFormat: "isoDateTime",
2230                displayFormat: void 0,
2231                outputFormat: void 0,
2232                min: null,
2233                max: null,
2234                skipOptionalPartCharacter: "",
2235                i18n: {
2236                    dayNames: [ "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday" ],
2237                    monthNames: [ "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "

2299                casing: function casing(elem, test, pos, validPositions) {
2300                    return 0 == test.nativeDef.indexOf("[ap]") ? elem.toLowerCase() : 0 == test.nativeDef.indexOf("[AP]") ? elem.toUpperCase() : elem;
2301                },
2302                onBeforeMask: function onBeforeMask(initialValue, opts) {
2303                    return "[object Date]" === Object.prototype.toString.call(initialValue) && (initialValue = importDate(initialValue, opts)), 
2304                    initialValue;
2305                },
2306                insertMode: !1,
2307                shiftPositions: !1,
2308                keepStatic: !1,
2309                inputmode: "numeric"
2310            }
2311        });
2312    }, function(module, exports, __webpack_require__) {
2313        "use strict";
2314        var _inputmask = _interopRequireDefault(__webpack_require__(1)), _keycode = _interopRequireDefault(__webpack_require__(0)), _escapeRegex = _interopRequireDefault(__webpack_require__(14));
2315        function _interopRequireDefault(obj) {
2316            return obj && obj.__esModule ? obj : {
2317                default: obj
2318            };
2319        }
2320        var $ = _inputmask.default.dependencyLib;
2321        function autoEscape(txt, opts) {
2322            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);
2323            return escapedTxt;
2324        }
2325        function alignDigits(buffer, digits, opts, force) {
2326            if (0 < buffer.length && 0 < digits && (!opts.digitsOptional || force)) {
2327                var radixPosition = buffer.indexOf(opts.radixPoint);
2328                -1 === radixPosition && (buffer.push(opts.radixPoint), radixPosition = buffer.length - 1);
2329                for (var i = 1; i <= digits; i++) isFinite(buffer[radixPosition + i]) || (buffer[radixPosition + i] = "0");
2330            }
2331            return buffer;
2332        }
2333        function findValidator(symbol, maskset) {
2334            var posNdx = 0;
2335            if ("+" === symbol) {
2336                for (posNdx in maskset.validPositions) ;
2337                posNdx = parseInt(posNdx);
2338            }
2339            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);
2340            return posNdx;
2341        }
2342        function findValid(symbol, maskset) {
2343            var ret = -1;
2344            for (var ndx in maskset.validPositions) {
2345                var tst = maskset.validPositions[ndx];
2346                if (tst && tst.match.def === symbol) {
2347                    ret = parseInt(ndx);
2348                    break;
2349                }
2350            }
2351            return ret;
2352        }
2353        function parseMinMaxOptions(opts) {
2354            void 0 === opts.parseMinMaxOptions && (null !== opts.min && (opts.min = opts.min.toString().replace(new RegExp((0, 
2355            _escapeRegex.default)(opts.groupSeparator), "g"), ""), "," === opts.radixPoint && (opts.min = opts.min.replace(opts.radixPoint, ".")), 
2356            opts.min = isFinite(opts.min) ? parseFloat(opts.min) : NaN, isNaN(opts.min) && (opts.min = Number.MIN_VALUE)), 
2357            null !== opts.max && (opts.max = opts.max.toString().replace(new RegExp((0, _escapeRegex.default)(opts.groupSeparator), "g"), ""), 
2358            "," === opts.radixPoint && (opts.max = opts.max.replace(opts.radixPoint, ".")), 
2359            opts.max = isFinite(opts.max) ? parseFloat(opts.max) : NaN, isNaN(opts.max) && (opts.max = Number.MAX_VALUE)), 
2360            opts.parseMinMaxOptions = "done");
2361        }
2362        function genMask(opts) {
2363            opts.repeat = 0, opts.groupSeparator === opts.radixPoint && opts.digits && "0" !== opts.digits && ("." === opts.radixPoint ? opts.groupSeparator = "," : "," === opts.radixPoint ? opts.groupSeparator = "." : opts.groupSeparator = ""), 
2364            " " === opts.groupSeparator && (opts.skipOptionalPartCharacter = void 0), 1 < opts.placeholder.length && (opts.placeholder = opts.placeholder.charAt(0)), 
2365            "radixFocus" === opts.positionCaretOnClick && "" === opts.placeholder && (opts.positionCaretOnClick = "lvp");
2366            var decimalDef = "0", radixPointDef = opts.radixPoint;
2367            !0 === opts.numericInput && void 0 === opts.__financeInput ? (decimalDef = "1", 
2368            opts.positionCaretOnClick = "radixFocus" === opts.positionCaretOnClick ? "lvp" : opts.positionCaretOnClick, 
2369            opts.digitsOptional = !1, isNaN(opts.digits) && (opts.digits = 2), opts._radixDance = !1, 
2370            radixPointDef = "," === opts.radixPoint ? "?" : "!", "" !== opts.radixPoint && void 0 === opts.definitions[radixPointDef] && (opts.definitions[radixPointDef] = {}, 
2371            opts.definitions[radixPointDef].validator = "[" + opts.radixPoint + "]", opts.definitions[radixPointDef].placeholder = opts.radixPoint, 
2372            opts.definitions[radixPointDef].static = !0, opts.definitions[radixPointDef].generated = !0)) : (opts.__financeInput = !1, 
2373            opts.numericInput = !0);
2374            var mask = "[+]", altMask;
2375            if (mask += autoEscape(opts.prefix, opts), "" !== opts.groupSeparator ? (void 0 === opts.definitions[opts.groupSeparator] && (opts.definitions[opts.groupSeparator] = {}, 
2376            opts.definitions[opts.groupSeparator].validator = "[" + opts.groupSeparator + "]", 
2377            opts.definitions[opts.groupSeparator].placeholder = opts.groupSeparator, opts.definitions[opts.groupSeparator].static = !0, 
2378            opts.definitions[opts.groupSeparator].generated = !0), mask += opts._mask(opts)) : mask += "9{+}", 
2379            void 0 !== opts.digits && 0 !== opts.digits) {
2380                var dq = opts.digits.toString().split(",");
2381                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 + "}", 
2382                opts.keepStatic = !0) : mask += radixPointDef + decimalDef + "{" + opts.digits + "}");
2383            }
2384            return mask += autoEscape(opts.suffix, opts), mask += "[-]", altMask && (mask = [ altMask + autoEscape(opts.suffix, opts) + "[-]", mask ]), 
2385            opts.greedy = !1, parseMinMaxOptions(opts), mask;
2386        }
2387        function hanndleRadixDance(pos, c, radixPos, maskset, opts) {
2388            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), 
2389            pos;
2390        }
2391        function decimalValidator(chrs, maskset, pos, strict, opts) {
2392            var radixPos = maskset.buffer ? maskset.buffer.indexOf(opts.radixPoint) : -1, result = -1 !== radixPos && new RegExp("[0-9\uff11-\uff19]").test(chrs);
2393            return opts._radixDance && result && null == maskset.validPositions[radixPos] ? {
2394                insert: {
2395                    pos: radixPos === pos ? radixPos + 1 : radixPos,
2396                    c: opts.radixPoint
2397                },
2398                pos: pos
2399            } : result;
2400        }
2401        function checkForLeadingZeroes(buffer, opts) {
2402            var numberMatches = new RegExp("(^" + ("" !== opts.negationSymbol.front ? (0, _escapeRegex.default)(opts.negationSymbol.front) + "?" : "") + (0, 
2403            _escapeRegex.default)(opts.prefix) + ")(.*)(" + (0, _escapeRegex.default)(opts.suffix) + ("" != opts.negationSymbol.back ? (0, 
2404            _escapeRegex.default)(opts.negationSymbol.back) + "?" : "") + "$)").exec(buffer.slice().reverse().join("")), number = numberMatches ? numberMatches[2] : "", leadingzeroes = !1;
2405            return number && (number = number.split(opts.radixPoint.charAt(0))[0], leadingzeroes = new RegExp("^[0" + opts.groupSeparator + "]*").exec(number)), 
2406            !(!leadingzeroes || !(1 < leadingzeroes[0].length || 0 < leadingzeroes[0].length && leadingzeroes[0].length < number.length)) && leadingzeroes;
2407        }
2408        _inputmask.default.extendAliases({
2409            numeric: {
2410                mask: genMask,
2411                _mask: function _mask(opts) {
2412                    return "(" + opts.groupSeparator + "999){+|1}";
2413                },
2414                digits: "*",
2415                digitsOptional: !0,
2416                enforceDigitsOnBlur: !1,
2417                radixPoint: ".",
2418                positionCaretOnClick: "radixFocus",
2419                _radixDance: !0,
2420                groupSeparator: "",
2421                allowMinus: !0,
2422                negationSymbol: {
2423                    front: "-",
2424                    back: ""
2425                },
2426                prefix: "",
2427                suffix: "",
2428                min: null,
2429                max: null,
2430                SetMaxOnOverflow: !1,
2431                step: 1,
2432                inputType: "text",
2433                unmaskAsNumber: !1,
2434                roundingFN: Math.round,
2435                inputmode: "numeric",
2436                shortcuts: {
2437                    k: "000",
2438                    m: "000000"
2439                },
2440                placeholder: "0",
2441                greedy: !1,
2442                rightAlign: !0,
2443                insertMode: !0,
2444                autoUnmask: !1,
2445                skipOptionalPartCharacter: "",
2446                definitions: {
2447                    0: {
2448                        validator: decimalValidator
2449                    },
2450                    1: {
2451                        validator: decimalValidator,
2452                        definitionSymbol: "9"
2453                    },
2454                    "+": {
2455                        validator: function validator(chrs, maskset, pos, strict, opts) {
2456                            return opts.allowMinus && ("-" === chrs || chrs === opts.negationSymbol.front);
2457                        }
2458                    },
2459                    "-": {
2460                        validator: function validator(chrs, maskset, pos, strict, opts) {
2461                            return opts.allowMinus && chrs === opts.negationSymbol.back;
2462                        }
2463                    }
2464                },
2465                preValidation: function preValidation(buffer, pos, c, isSelection, opts, maskset, caretPos, strict) {
2466                    if (!1 !== opts.__financeInput && c === opts.radixPoint) return !1;
2467                    var pattern;
2468                    if (pattern = opts.shortcuts && opts.shortcuts[c]) {
2469                        if (1 < pattern.length) for (var inserts = [], i = 0; i < pattern.length; i++) inserts.push({
2470                            pos: pos + i,
2471                            c: pattern[i],
2472                            strict: !1
2473                        });
2474                        return {
2475                            insert: inserts
2476                        };
2477                    }
2478                    var radixPos = buffer.indexOf(opts.radixPoint), initPos = pos;
2479                    if (pos = hanndleRadixDance(pos, c, radixPos, maskset, opts), "-" === c || c === opts.negationSymbol.front) {
2480                        if (!0 !== opts.allowMinus) return !1;
2481                        var isNegative = !1, front = findValid("+", maskset), back = findValid("-", maskset);
2482                        return -1 !== front && (isNegative = [ front, back ]), !1 !== isNegative ? {
2483                            remove: isNegative,
2484                            caret: initPos
2485                        } : {
2486                            insert: [ {
2487                                pos: findValidator("+", maskset),
2488                                c: opts.negationSymbol.front,
2489                                fromIsValid: !0
2490                            }, {
2491                                pos: findValidator("-", maskset),
2492                                c: opts.negationSymbol.back,
2493                                fromIsValid: void 0
2494                            } ],
2495                            caret: initPos + opts.negationSymbol.back.length
2496                        };
2497                    }
2498                    if (strict) return !0;
2499                    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 {
2500                        caret: opts._radixDance && pos === radixPos - 1 ? radixPos + 1 : radixPos
2501                    };
2502                    if (!1 === opts.__financeInput) if (isSelection) {
2503                        if (opts.digitsOptional) return {
2504                            rewritePosition: caretPos.end
2505                        };
2506                        if (!opts.digitsOptional) {
2507                            if (caretPos.begin > radixPos && caretPos.end <= radixPos) return c === opts.radixPoint ? {
2508                                insert: {
2509                                    pos: radixPos + 1,
2510                                    c: "0",
2511                                    fromIsValid: !0
2512                                },
2513                                rewritePosition: radixPos
2514                            } : {
2515                                rewritePosition: radixPos + 1
2516                            };
2517                            if (caretPos.begin < radixPos) return {
2518                                rewritePosition: caretPos.begin - 1
2519                            };
2520                        }
2521                    } else if (!opts.showMaskOnHover && !opts.showMaskOnFocus && !opts.digitsOptional && 0 < opts.digits && "" === this.inputmask.__valueGet.call(this)) return {
2522                        rewritePosition: radixPos
2523                    };
2524                    return {
2525                        rewritePosition: pos
2526                    };
2527                },
2528                postValidation: function postValidation(buffer, pos, c, currentResult, opts, maskset, strict) {
2529                    if (!1 === currentResult) return currentResult;
2530                    if (strict) return !0;
2531                    if (null !== opts.min || null !== opts.max) {
2532                        var unmasked = opts.onUnMask(buffer.slice().reverse().join(""), void 0, $.extend({}, opts, {
2533                            unmaskAsNumber: !0
2534                        }));
2535                        if (null !== opts.min && unmasked < opts.min && (unmasked.toString().length > opts.min.toString().length || unmasked < 0)) return !1;
2536                        if (null !== opts.max && unmasked > opts.max) return !!opts.SetMaxOnOverflow && {
2537                            refreshFromBuffer: !0,
2538                            buffer: alignDigits(opts.max.toString().replace(".", opts.radixPoint).split(""), opts.digits, opts).reverse()
2539                        };
2540                    }
2541                    return currentResult;
2542                },
2543                onUnMask: function onUnMask(maskedValue, unmaskedValue, opts) {
2544                    if ("" === unmaskedValue && !0 === opts.nullable) return unmaskedValue;
2545                    var processValue = maskedValue.replace(opts.prefix, "");
2546                    return processValue = processValue.replace(opts.suffix, ""), processValue = processValue.replace(new RegExp((0, 
2547                    _escapeRegex.default)(opts.groupSeparator), "g"), ""), "" !== opts.placeholder.charAt(0) && (processValue = processValue.replace(new RegExp(opts.placeholder.charAt(0), "g"), "0")), 
2548                    opts.unmaskAsNumber ? ("" !== opts.radixPoint && -1 !== processValue.indexOf(opts.radixPoint) && (processValue = processValue.replace(_escapeRegex.default.call(this, opts.radixPoint), ".")), 
2549                    processValue = processValue.replace(new RegExp("^" + (0, _escapeRegex.default)(opts.negationSymbol.front)), "-"), 
2550                    processValue = processValue.replace(new RegExp((0, _escapeRegex.default)(opts.negationSymbol.back) + "$"), ""), 
2551                    Number(processValue)) : processValue;
2552                },
2553                isComplete: function isComplete(buffer, opts) {
2554                    var maskedValue = (opts.numericInput ? buffer.slice().reverse() : buffer).join("");
2555                    return maskedValue = maskedValue.replace(new RegExp("^" + (0, _escapeRegex.default)(opts.negationSymbol.front)), "-"), 
2556                    maskedValue = maskedValue.replace(new RegExp((0, _escapeRegex.default)(opts.negationSymbol.back) + "$"), ""), 
2557                    maskedValue = maskedValue.replace(opts.prefix, ""), maskedValue = maskedValue.replace(opts.suffix, ""), 
2558                    maskedValue = maskedValue.replace(new RegExp((0, _escapeRegex.default)(opts.groupSeparator) + "([0-9]{3})", "g"), "$1"), 
2559                    "," === opts.radixPoint && (maskedValue = maskedValue.replace((0, _escapeRegex.default)(opts.radixPoint), ".")), 
2560                    isFinite(maskedValue);
2561                },
2562                onBeforeMask: function onBeforeMask(initialValue, opts) {
2563                    var radixPoint = opts.radixPoint || ",";
2564                    isFinite(opts.digits) && (opts.digits = parseInt(opts.digits)), "number" != typeof initialValue && "number" !== opts.inputType || "" === radixPoint || (initialValue = initialValue.toString().replace(".", radixPoint));
2565                    var 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;
2566                    initialValue = integerPart + ("" !== decimalPart ? radixPoint + decimalPart : decimalPart);
2567                    var digits = 0;
2568                    if ("" !== radixPoint && (digits = opts.digitsOptional ? opts.digits < decimalPart.length ? opts.digits : decimalPart.length : opts.digits, 
2569                    "" !== decimalPart || !opts.digitsOptional)) {
2570                        var digitsFactor = Math.pow(10, digits || 1);
2571                        initialValue = initialValue.replace((0, _escapeRegex.default)(radixPoint), "."), 
2572                        isNaN(parseFloat(initialValue)) || (initialValue = (opts.roundingFN(parseFloat(initialValue) * digitsFactor) / digitsFactor).toFixed(digits)), 
2573                        initialValue = initialValue.toString().replace(".", radixPoint);
2574                    }
2575                    if (0 === opts.digits && -1 !== initialValue.indexOf(radixPoint) && (initialValue = initialValue.substring(0, initialValue.indexOf(radixPoint))), 
2576                    null !== opts.min || null !== opts.max) {
2577                        var numberValue = initialValue.toString().replace(radixPoint, ".");
2578                        null !== opts.min && numberValue < opts.min ? initialValue = opts.min.toString().replace(".", radixPoint) : null !== opts.max && numberValue > opts.max && (initialValue = opts.max.toString().replace(".", radixPoint));
2579                    }
2580                    return alignDigits(initialValue.toString().split(""), digits, opts, forceDigits).join("");
2581                },
2582                onBeforeWrite: function onBeforeWrite(e, buffer, caretPos, opts) {
2583                    function stripBuffer(buffer, stripRadix) {
2584                        if (!1 !== opts.__financeInput || stripRadix) {
2585                            var position = buffer.indexOf(opts.radixPoint);
2586                            -1 !== position && buffer.splice(position, 1);
2587                        }
2588                        if ("" !== opts.groupSeparator) for (;-1 !== (position = buffer.indexOf(opts.groupSeparator)); ) buffer.splice(position, 1);
2589                        return buffer;
2590                    }
2591                    var result, leadingzeroes = checkForLeadingZeroes(buffer, opts);
2592                    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], 
2593                    delete buffer[caretNdx + i];
2594                    if (e) switch (e.type) {
2595                      case "blur":
2596                      case "checkval":
2597                        if (null !== opts.min) {
2598                            var unmasked = opts.onUnMask(buffer.slice().reverse().join(""), void 0, $.extend({}, opts, {
2599                                unmaskAsNumber: !0
2600                            }));
2601                            if (null !== opts.min && unmasked < opts.min) return {
2602                                refreshFromBuffer: !0,
2603                                buffer: alignDigits(opts.min.toString().replace(".", opts.radixPoint).split(""), opts.digits, opts).reverse()
2604                            };
2605                        }
2606                        if (buffer[buffer.length - 1] === opts.negationSymbol.front) {
2607                            var nmbrMtchs = new RegExp("(^" + ("" != opts.negationSymbol.front ? (0, _escapeRegex.default)(opts.negationSymbol.front) + "?" : "") + (0, 
2608                            _escapeRegex.default)(opts.prefix) + ")(.*)(" + (0, _escapeRegex.default)(opts.suffix) + ("" != opts.negationSymbol.back ? (0, 
2609                            _escapeRegex.default)(opts.negationSymbol.back) + "?" : "") + "$)").exec(stripBuffer(buffer.slice(), !0).reverse().join("")), number = nmbrMtchs ? nmbrMtchs[2] : "";
2610                            0 == number && (result = {
2611                                refreshFromBuffer: !0,
2612                                buffer: [ 0 ]
2613                            });
2614                        } else "" !== opts.radixPoint && buffer[0] === opts.radixPoint && (result && result.buffer ? result.buffer.shift() : (buffer.shift(), 
2615                        result = {
2616                            refreshFromBuffer: !0,
2617                            buffer: stripBuffer(buffer)
2618                        }));
2619                        if (opts.enforceDigitsOnBlur) {
2620                            result = result || {};
2621                            var bffr = result && result.buffer || buffer.slice().reverse();
2622                            result.refreshFromBuffer = !0, result.buffer = alignDigits(bffr, opts.digits, opts, !0).reverse();
2623                        }
2624                    }
2625                    return result;
2626                },
2627                onKeyDown: function onKeyDown(e, buffer, caretPos, opts) {
2628                    var $input = $(this), bffr;
2629                    if (e.ctrlKey) switch (e.keyCode) {
2630                      case _keycode.default.UP:
2631                        return this.inputmask.__valueSet.call(this, parseFloat(this.inputmask.unmaskedvalue()) + parseInt(opts.step)), 
2632                        $input.trigger("setvalue"), !1;
2633
2634                      case _keycode.default.DOWN:
2635                        return this.inputmask.__valueSet.call(this, parseFloat(this.inputmask.unmaskedvalue()) - parseInt(opts.step)), 
2636                        $input.trigger("setvalue"), !1;
2637                    }
2638                    if (!e.shiftKey && (e.keyCode === _keycode.default.DELETE || e.keyCode === _keycode.default.BACKSPACE || e.keyCode === _keycode.default.BACKSPACE_SAFARI) && caretPos.begin !== buffer.length) {
2639                        if (buffer[e.keyCode === _keycode.default.DELETE ? caretPos.begin - 1 : caretPos.end] === opts.negationSymbol.front) return bffr = buffer.slice().reverse(), 
2640                        "" !== opts.negationSymbol.front && bffr.shift(), "" !== opts.negationSymbol.back && bffr.pop(), 
2641                        $input.trigger("setvalue", [ bffr.join(""), caretPos.begin ]), !1;
2642                        if (!0 === opts._radixDance) {
2643                            var radixPos = buffer.indexOf(opts.radixPoint);
2644                            if (opts.digitsOptional) {
2645                                if (0 === radixPos) return bffr = buffer.slice().reverse(), bffr.pop(), $input.trigger("setvalue", [ bffr.join(""), caretPos.begin >= bffr.length ? bffr.length : caretPos.begin ]), 
2646                                !1;
2647                            } else if (-1 !== radixPos && (caretPos.begin < radixPos || caretPos.end < radixPos || e.keyCode === _keycode.default.DELETE && c