text: /*!
  * jquery.inputmask.regex.extensions.js
  * http://github.com/RobinHerbots/jquery.inputmask
  * Copyright (c) 2010 - 2014 Robin Herbots
  * Licensed under the MIT license (http://www.opensource.org/licenses/mit-license.php)
  * Version: 3.1.49
  */
  !function(factory) {
      "function" == typeof define && define.amd ? define([ "jquery", "./jquery.inputmask" ], factory) : factory(jQuery);
  }(function($) {
      return $.extend($.inputmask.defaults.aliases, {
          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).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 analyseRegex() {
                              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 ")":
                                  var 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;
                                      if (match = matches.pop(), !match.isGroup) {
                                          var groupToken = new regexToken(!0);
                                          groupToken.matches.push(match), match = groupToken;
                                      }
                                      matches.push(match), matches.push(quantifierToken);
                                  } else {
                                      if (match = currentToken.matches.pop(), !match.isGroup) {
                                          var 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);
                          }
                          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 (1 == matchToken.isGroup) isvalid = validateRegexToken(matchToken, !0); else if (1 == 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; qm > i && !(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; openGroupCount > j; j++) testExp += ")";
                                          var exp = new RegExp("^(" + testExp + ")$");
                                          isvalid = exp.test(bufferStr);
                                      } else for (var l = 0, tl = matchToken.length; tl > l; l++) if ("\\" != matchToken.charAt(l)) {
                                          testExp = regexPart, testExp += matchToken.substr(0, l + 1), testExp = testExp.replace(/\|$/, "");
                                          for (var j = 0; openGroupCount > j; j++) testExp += ")";
                                          var exp = new RegExp("^(" + testExp + ")$");
                                          if (isvalid = exp.test(bufferStr)) break;
                                      }
                                      regexPart += matchToken;
                                  }
                                  if (isvalid) break;
                              }
                              return fromGroup && (regexPart += ")", openGroupCount--), isvalid;
                          }
                          null == opts.regexTokens && analyseRegex();
                          var cbuffer = maskset.buffer.slice(), regexPart = "", isValid = !1, openGroupCount = 0;
                          cbuffer.splice(pos, 0, chrs);
                          for (var bufferStr = cbuffer.join(""), i = 0; i < opts.regexTokens.length; i++) {
                              var regexToken = opts.regexTokens[i];
                              if (isValid = validateRegexToken(regexToken, regexToken.isGroup)) break;
                          }
                          return isValid;
                      },
                      cardinality: 1
                  }
              }
          }
      }), $.fn.inputmask;
  });