/*!

*/

!function(factory) {

"function" == typeof define && define.amd ? define([ "./dependencyLibs/inputmask.dependencyLib", "./inputmask" ], factory) : "object" == typeof exports ? module.exports = factory(require("./dependencyLibs/inputmask.dependencyLib"), require("./inputmask")) : factory(window.dependencyLib || jQuery, window.Inputmask);

}(function($, Inputmask) {

return Inputmask.extendAliases({
    Regex: {
        mask: "r",
        greedy: !1,
        repeat: "*",
        regex: null,
        regexTokens: null,
        tokenizer: /\[\^?]?(?:[^\\\]]+|\\[\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,
        quantifierFilter: /[0-9]+[^,]/,
        isComplete: function(buffer, opts) {
            return new RegExp(opts.regex, opts.casing ? "i" : "").test(buffer.join(""));
        },
        definitions: {
            r: {
                validator: function(chrs, maskset, pos, strict, opts) {
                    function RegexToken(isGroup, isQuantifier) {
                        this.matches = [], this.isGroup = isGroup || !1, this.isQuantifier = isQuantifier || !1, 
                        this.quantifier = {
                            min: 1,
                            max: 1
                        }, this.repeaterPart = void 0;
                    }
                    function validateRegexToken(token, fromGroup) {
                        var isvalid = !1;
                        fromGroup && (regexPart += "(", openGroupCount++);
                        for (var mndx = 0; mndx < token.matches.length; mndx++) {
                            var matchToken = token.matches[mndx];
                            if (!0 === matchToken.isGroup) isvalid = validateRegexToken(matchToken, !0); else if (!0 === matchToken.isQuantifier) {
                                var crrntndx = $.inArray(matchToken, token.matches), matchGroup = token.matches[crrntndx - 1], regexPartBak = regexPart;
                                if (isNaN(matchToken.quantifier.max)) {
                                    for (;matchToken.repeaterPart && matchToken.repeaterPart !== regexPart && matchToken.repeaterPart.length > regexPart.length && !(isvalid = validateRegexToken(matchGroup, !0)); ) ;
                                    isvalid = isvalid || validateRegexToken(matchGroup, !0), isvalid && (matchToken.repeaterPart = regexPart), 
                                    regexPart = regexPartBak + matchToken.quantifier.max;
                                } else {
                                    for (var i = 0, qm = matchToken.quantifier.max - 1; i < qm && !(isvalid = validateRegexToken(matchGroup, !0)); i++) ;
                                    regexPart = regexPartBak + "{" + matchToken.quantifier.min + "," + matchToken.quantifier.max + "}";
                                }
                            } else if (void 0 !== matchToken.matches) for (var k = 0; k < matchToken.length && !(isvalid = validateRegexToken(matchToken[k], fromGroup)); k++) ; else {
                                var testExp;
                                if ("[" == matchToken.charAt(0)) {
                                    testExp = regexPart, testExp += matchToken;
                                    for (var j = 0; j < openGroupCount; j++) testExp += ")";
                                    var exp = new RegExp("^(" + testExp + ")$", opts.casing ? "i" : "");
                                    isvalid = exp.test(bufferStr);
                                } else for (var l = 0, tl = matchToken.length; l < tl; l++) if ("\\" !== matchToken.charAt(l)) {
                                    testExp = regexPart, testExp += matchToken.substr(0, l + 1), testExp = testExp.replace(/\|$/, "");
                                    for (var j = 0; j < openGroupCount; j++) testExp += ")";
                                    var exp = new RegExp("^(" + testExp + ")$", opts.casing ? "i" : "");
                                    if (isvalid = exp.test(bufferStr)) break;
                                }
                                regexPart += matchToken;
                            }
                            if (isvalid) break;
                        }
                        return fromGroup && (regexPart += ")", openGroupCount--), isvalid;
                    }
                    var bufferStr, groupToken, cbuffer = maskset.buffer.slice(), regexPart = "", isValid = !1, openGroupCount = 0;
                    null === opts.regexTokens && function() {
                        var match, m, currentToken = new RegexToken(), opengroups = [];
                        for (opts.regexTokens = []; match = opts.tokenizer.exec(opts.regex); ) switch (m = match[0], 
                        m.charAt(0)) {
                          case "(":
                            opengroups.push(new RegexToken(!0));
                            break;

                          case ")":
                            groupToken = opengroups.pop(), opengroups.length > 0 ? opengroups[opengroups.length - 1].matches.push(groupToken) : currentToken.matches.push(groupToken);
                            break;

                          case "{":
                          case "+":
                          case "*":
                            var quantifierToken = new RegexToken(!1, !0);
                            m = m.replace(/[{}]/g, "");
                            var mq = m.split(","), mq0 = isNaN(mq[0]) ? mq[0] : parseInt(mq[0]), mq1 = 1 === mq.length ? mq0 : isNaN(mq[1]) ? mq[1] : parseInt(mq[1]);
                            if (quantifierToken.quantifier = {
                                min: mq0,
                                max: mq1
                            }, opengroups.length > 0) {
                                var matches = opengroups[opengroups.length - 1].matches;
                                match = matches.pop(), match.isGroup || (groupToken = new RegexToken(!0), groupToken.matches.push(match), 
                                match = groupToken), matches.push(match), matches.push(quantifierToken);
                            } else match = currentToken.matches.pop(), match.isGroup || (groupToken = new RegexToken(!0), 
                            groupToken.matches.push(match), match = groupToken), currentToken.matches.push(match), 
                            currentToken.matches.push(quantifierToken);
                            break;

                          default:
                            opengroups.length > 0 ? opengroups[opengroups.length - 1].matches.push(m) : currentToken.matches.push(m);
                        }
                        currentToken.matches.length > 0 && opts.regexTokens.push(currentToken);
                    }(), cbuffer.splice(pos, 0, chrs), bufferStr = cbuffer.join("");
                    for (var i = 0; i < opts.regexTokens.length; i++) {
                        var regexToken = opts.regexTokens[i];
                        if (isValid = validateRegexToken(regexToken, regexToken.isGroup)) break;
                    }
                    return isValid;
                },
                cardinality: 1
            }
        }
    }
}), Inputmask;

});