/*!

* inputmask.regex.extensions.js

* https://github.com/RobinHerbots/Inputmask

* Copyright (c) 2010 - 2017 Robin Herbots

* Licensed under the MIT license (http://www.opensource.org/licenses/mit-license.php)

* Version: 3.3.11

*/



!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)) && (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 (j = 0; j < openGroupCount; j++) testExp += ")";

                                        isvalid = (exp = new RegExp("^(" + testExp + ")$", opts.casing ? "i" : "")).test(bufferStr);

                                    } else for (var l = 0, tl = matchToken.length; l < tl; l++) if ("\\" !== matchToken.charAt(l)) {

                                        testExp = regexPart, testExp = (testExp += matchToken.substr(0, l + 1)).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]).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), mq = (m = m.replace(/[{}]/g, "")).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()).isGroup || ((groupToken = new RegexToken(!0)).matches.push(match), 

                                    match = groupToken), matches.push(match), matches.push(quantifierToken);

                                } else (match = currentToken.matches.pop()).isGroup || ((groupToken = new RegexToken(!0)).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;

});