226 lines
9.0 KiB
JavaScript
226 lines
9.0 KiB
JavaScript
/*!
|
|
* 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
|
|
);
|
|
});
|