4005 lines
150 KiB
JavaScript
4005 lines
150 KiB
JavaScript
/*!
|
||
* inputmask.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",
|
||
"./global/window",
|
||
"./global/document",
|
||
],
|
||
factory
|
||
)
|
||
: "object" == typeof exports
|
||
? (module.exports = factory(
|
||
require("./dependencyLibs/inputmask.dependencyLib"),
|
||
require("./global/window"),
|
||
require("./global/document")
|
||
))
|
||
: (window.Inputmask = factory(
|
||
window.dependencyLib || jQuery,
|
||
window,
|
||
document
|
||
));
|
||
})(function ($, window, document, undefined) {
|
||
function Inputmask(alias, options, internal) {
|
||
if (!(this instanceof Inputmask))
|
||
return new Inputmask(alias, options, internal);
|
||
(this.el = undefined),
|
||
(this.events = {}),
|
||
(this.maskset = undefined),
|
||
(this.refreshValue = !1),
|
||
!0 !== internal &&
|
||
($.isPlainObject(alias)
|
||
? (options = alias)
|
||
: ((options = options || {}).alias = alias),
|
||
(this.opts = $.extend(!0, {}, this.defaults, options)),
|
||
(this.noMasksCache = options && options.definitions !== undefined),
|
||
(this.userOptions = options || {}),
|
||
(this.isRTL = this.opts.numericInput),
|
||
resolveAlias(this.opts.alias, options, this.opts));
|
||
}
|
||
function resolveAlias(aliasStr, options, opts) {
|
||
var aliasDefinition = Inputmask.prototype.aliases[aliasStr];
|
||
return aliasDefinition
|
||
? (aliasDefinition.alias &&
|
||
resolveAlias(aliasDefinition.alias, undefined, opts),
|
||
$.extend(!0, opts, aliasDefinition),
|
||
$.extend(!0, opts, options),
|
||
!0)
|
||
: (null === opts.mask && (opts.mask = aliasStr), !1);
|
||
}
|
||
function generateMaskSet(opts, nocache) {
|
||
function generateMask(mask, metadata, opts) {
|
||
var regexMask = !1;
|
||
if (
|
||
((null !== mask && "" !== mask) ||
|
||
((regexMask = null !== opts.regex)
|
||
? (mask = (mask = opts.regex).replace(/^(\^)(.*)(\$)$/, "$2"))
|
||
: ((regexMask = !0), (mask = ".*"))),
|
||
1 === mask.length &&
|
||
!1 === opts.greedy &&
|
||
0 !== opts.repeat &&
|
||
(opts.placeholder = ""),
|
||
opts.repeat > 0 || "*" === opts.repeat || "+" === opts.repeat)
|
||
) {
|
||
var repeatStart =
|
||
"*" === opts.repeat ? 0 : "+" === opts.repeat ? 1 : opts.repeat;
|
||
mask =
|
||
opts.groupmarker.start +
|
||
mask +
|
||
opts.groupmarker.end +
|
||
opts.quantifiermarker.start +
|
||
repeatStart +
|
||
"," +
|
||
opts.repeat +
|
||
opts.quantifiermarker.end;
|
||
}
|
||
var masksetDefinition,
|
||
maskdefKey = regexMask
|
||
? "regex_" + opts.regex
|
||
: opts.numericInput
|
||
? mask.split("").reverse().join("")
|
||
: mask;
|
||
return (
|
||
Inputmask.prototype.masksCache[maskdefKey] === undefined ||
|
||
!0 === nocache
|
||
? ((masksetDefinition = {
|
||
mask: mask,
|
||
maskToken: Inputmask.prototype.analyseMask(mask, regexMask, opts),
|
||
validPositions: {},
|
||
_buffer: undefined,
|
||
buffer: undefined,
|
||
tests: {},
|
||
metadata: metadata,
|
||
maskLength: undefined,
|
||
}),
|
||
!0 !== nocache &&
|
||
((Inputmask.prototype.masksCache[maskdefKey] = masksetDefinition),
|
||
(masksetDefinition = $.extend(
|
||
!0,
|
||
{},
|
||
Inputmask.prototype.masksCache[maskdefKey]
|
||
))))
|
||
: (masksetDefinition = $.extend(
|
||
!0,
|
||
{},
|
||
Inputmask.prototype.masksCache[maskdefKey]
|
||
)),
|
||
masksetDefinition
|
||
);
|
||
}
|
||
if (
|
||
($.isFunction(opts.mask) && (opts.mask = opts.mask(opts)),
|
||
$.isArray(opts.mask))
|
||
) {
|
||
if (opts.mask.length > 1) {
|
||
opts.keepStatic = null === opts.keepStatic || opts.keepStatic;
|
||
var altMask = opts.groupmarker.start;
|
||
return (
|
||
$.each(
|
||
opts.numericInput ? opts.mask.reverse() : opts.mask,
|
||
function (ndx, msk) {
|
||
altMask.length > 1 &&
|
||
(altMask +=
|
||
opts.groupmarker.end +
|
||
opts.alternatormarker +
|
||
opts.groupmarker.start),
|
||
msk.mask === undefined || $.isFunction(msk.mask)
|
||
? (altMask += msk)
|
||
: (altMask += msk.mask);
|
||
}
|
||
),
|
||
(altMask += opts.groupmarker.end),
|
||
generateMask(altMask, opts.mask, opts)
|
||
);
|
||
}
|
||
opts.mask = opts.mask.pop();
|
||
}
|
||
return opts.mask &&
|
||
opts.mask.mask !== undefined &&
|
||
!$.isFunction(opts.mask.mask)
|
||
? generateMask(opts.mask.mask, opts.mask, opts)
|
||
: generateMask(opts.mask, opts.mask, opts);
|
||
}
|
||
function maskScope(actionObj, maskset, opts) {
|
||
function getMaskTemplate(baseOnInput, minimalPos, includeMode) {
|
||
minimalPos = minimalPos || 0;
|
||
var ndxIntlzr,
|
||
test,
|
||
testPos,
|
||
maskTemplate = [],
|
||
pos = 0,
|
||
lvp = getLastValidPosition();
|
||
do {
|
||
!0 === baseOnInput && getMaskSet().validPositions[pos]
|
||
? ((test = (testPos = getMaskSet().validPositions[pos]).match),
|
||
(ndxIntlzr = testPos.locator.slice()),
|
||
maskTemplate.push(
|
||
!0 === includeMode
|
||
? testPos.input
|
||
: !1 === includeMode
|
||
? test.nativeDef
|
||
: getPlaceholder(pos, test)
|
||
))
|
||
: ((test = (testPos = getTestTemplate(pos, ndxIntlzr, pos - 1))
|
||
.match),
|
||
(ndxIntlzr = testPos.locator.slice()),
|
||
(!1 === opts.jitMasking ||
|
||
pos < lvp ||
|
||
("number" == typeof opts.jitMasking &&
|
||
isFinite(opts.jitMasking) &&
|
||
opts.jitMasking > pos)) &&
|
||
maskTemplate.push(
|
||
!1 === includeMode ? test.nativeDef : getPlaceholder(pos, test)
|
||
)),
|
||
pos++;
|
||
} while (((maxLength === undefined || pos < maxLength) && (null !== test.fn || "" !== test.def)) || minimalPos > pos);
|
||
return (
|
||
"" === maskTemplate[maskTemplate.length - 1] && maskTemplate.pop(),
|
||
(getMaskSet().maskLength = pos + 1),
|
||
maskTemplate
|
||
);
|
||
}
|
||
function getMaskSet() {
|
||
return maskset;
|
||
}
|
||
function resetMaskSet(soft) {
|
||
var maskset = getMaskSet();
|
||
(maskset.buffer = undefined),
|
||
!0 !== soft && ((maskset.validPositions = {}), (maskset.p = 0));
|
||
}
|
||
function getLastValidPosition(closestTo, strict, validPositions) {
|
||
var before = -1,
|
||
after = -1,
|
||
valids = validPositions || getMaskSet().validPositions;
|
||
closestTo === undefined && (closestTo = -1);
|
||
for (var posNdx in valids) {
|
||
var psNdx = parseInt(posNdx);
|
||
valids[psNdx] &&
|
||
(strict || !0 !== valids[psNdx].generatedInput) &&
|
||
(psNdx <= closestTo && (before = psNdx),
|
||
psNdx >= closestTo && (after = psNdx));
|
||
}
|
||
return (-1 !== before && closestTo - before > 1) || after < closestTo
|
||
? before
|
||
: after;
|
||
}
|
||
function stripValidPositions(start, end, nocheck, strict) {
|
||
var i,
|
||
startPos = start,
|
||
positionsClone = $.extend(!0, {}, getMaskSet().validPositions),
|
||
needsValidation = !1;
|
||
for (getMaskSet().p = start, i = end - 1; i >= startPos; i--)
|
||
getMaskSet().validPositions[i] !== undefined &&
|
||
((!0 !== nocheck &&
|
||
((!getMaskSet().validPositions[i].match.optionality &&
|
||
(function (pos) {
|
||
var posMatch = getMaskSet().validPositions[pos];
|
||
if (posMatch !== undefined && null === posMatch.match.fn) {
|
||
var prevMatch = getMaskSet().validPositions[pos - 1],
|
||
nextMatch = getMaskSet().validPositions[pos + 1];
|
||
return prevMatch !== undefined && nextMatch !== undefined;
|
||
}
|
||
return !1;
|
||
})(i)) ||
|
||
!1 ===
|
||
opts.canClearPosition(
|
||
getMaskSet(),
|
||
i,
|
||
getLastValidPosition(),
|
||
strict,
|
||
opts
|
||
))) ||
|
||
delete getMaskSet().validPositions[i]);
|
||
for (resetMaskSet(!0), i = startPos + 1; i <= getLastValidPosition(); ) {
|
||
for (; getMaskSet().validPositions[startPos] !== undefined; )
|
||
startPos++;
|
||
if (
|
||
(i < startPos && (i = startPos + 1),
|
||
getMaskSet().validPositions[i] === undefined && isMask(i))
|
||
)
|
||
i++;
|
||
else {
|
||
var t = getTestTemplate(i);
|
||
!1 === needsValidation &&
|
||
positionsClone[startPos] &&
|
||
positionsClone[startPos].match.def === t.match.def
|
||
? ((getMaskSet().validPositions[startPos] = $.extend(
|
||
!0,
|
||
{},
|
||
positionsClone[startPos]
|
||
)),
|
||
(getMaskSet().validPositions[startPos].input = t.input),
|
||
delete getMaskSet().validPositions[i],
|
||
i++)
|
||
: positionCanMatchDefinition(startPos, t.match.def)
|
||
? !1 !== isValid(startPos, t.input || getPlaceholder(i), !0) &&
|
||
(delete getMaskSet().validPositions[i],
|
||
i++,
|
||
(needsValidation = !0))
|
||
: isMask(i) || (i++, startPos--),
|
||
startPos++;
|
||
}
|
||
}
|
||
resetMaskSet(!0);
|
||
}
|
||
function determineTestTemplate(tests, guessNextBest) {
|
||
for (
|
||
var testPos,
|
||
testPositions = tests,
|
||
lvp = getLastValidPosition(),
|
||
lvTest = getMaskSet().validPositions[lvp] || getTests(0)[0],
|
||
lvTestAltArr =
|
||
lvTest.alternation !== undefined
|
||
? lvTest.locator[lvTest.alternation].toString().split(",")
|
||
: [],
|
||
ndx = 0;
|
||
ndx < testPositions.length &&
|
||
(!(
|
||
(testPos = testPositions[ndx]).match &&
|
||
((opts.greedy && !0 !== testPos.match.optionalQuantifier) ||
|
||
((!1 === testPos.match.optionality ||
|
||
!1 === testPos.match.newBlockMarker) &&
|
||
!0 !== testPos.match.optionalQuantifier)) &&
|
||
(lvTest.alternation === undefined ||
|
||
lvTest.alternation !== testPos.alternation ||
|
||
(testPos.locator[lvTest.alternation] !== undefined &&
|
||
checkAlternationMatch(
|
||
testPos.locator[lvTest.alternation].toString().split(","),
|
||
lvTestAltArr
|
||
)))
|
||
) ||
|
||
(!0 === guessNextBest &&
|
||
(null !== testPos.match.fn ||
|
||
/[0-9a-bA-Z]/.test(testPos.match.def))));
|
||
ndx++
|
||
);
|
||
return testPos;
|
||
}
|
||
function getTestTemplate(pos, ndxIntlzr, tstPs) {
|
||
return (
|
||
getMaskSet().validPositions[pos] ||
|
||
determineTestTemplate(
|
||
getTests(pos, ndxIntlzr ? ndxIntlzr.slice() : ndxIntlzr, tstPs)
|
||
)
|
||
);
|
||
}
|
||
function getTest(pos) {
|
||
return getMaskSet().validPositions[pos]
|
||
? getMaskSet().validPositions[pos]
|
||
: getTests(pos)[0];
|
||
}
|
||
function positionCanMatchDefinition(pos, def) {
|
||
for (
|
||
var valid = !1, tests = getTests(pos), tndx = 0;
|
||
tndx < tests.length;
|
||
tndx++
|
||
)
|
||
if (tests[tndx].match && tests[tndx].match.def === def) {
|
||
valid = !0;
|
||
break;
|
||
}
|
||
return valid;
|
||
}
|
||
function getTests(pos, ndxIntlzr, tstPs) {
|
||
function resolveTestFromToken(
|
||
maskToken,
|
||
ndxInitializer,
|
||
loopNdx,
|
||
quantifierRecurse
|
||
) {
|
||
function handleMatch(match, loopNdx, quantifierRecurse) {
|
||
function isFirstMatch(latestMatch, tokenGroup) {
|
||
var firstMatch = 0 === $.inArray(latestMatch, tokenGroup.matches);
|
||
return (
|
||
firstMatch ||
|
||
$.each(tokenGroup.matches, function (ndx, match) {
|
||
if (
|
||
!0 === match.isQuantifier &&
|
||
(firstMatch = isFirstMatch(
|
||
latestMatch,
|
||
tokenGroup.matches[ndx - 1]
|
||
))
|
||
)
|
||
return !1;
|
||
}),
|
||
firstMatch
|
||
);
|
||
}
|
||
function resolveNdxInitializer(pos, alternateNdx, targetAlternation) {
|
||
var bestMatch, indexPos;
|
||
if (
|
||
getMaskSet().validPositions[pos - 1] &&
|
||
targetAlternation &&
|
||
getMaskSet().tests[pos]
|
||
)
|
||
for (
|
||
var vpAlternation =
|
||
getMaskSet().validPositions[pos - 1].locator,
|
||
tpAlternation = getMaskSet().tests[pos][0].locator,
|
||
i = 0;
|
||
i < targetAlternation;
|
||
i++
|
||
)
|
||
if (vpAlternation[i] !== tpAlternation[i])
|
||
return vpAlternation.slice(targetAlternation + 1);
|
||
return (
|
||
(getMaskSet().tests[pos] || getMaskSet().validPositions[pos]) &&
|
||
$.each(
|
||
getMaskSet().tests[pos] || [getMaskSet().validPositions[pos]],
|
||
function (ndx, lmnt) {
|
||
var alternation =
|
||
targetAlternation !== undefined
|
||
? targetAlternation
|
||
: lmnt.alternation,
|
||
ndxPos =
|
||
lmnt.locator[alternation] !== undefined
|
||
? lmnt.locator[alternation]
|
||
.toString()
|
||
.indexOf(alternateNdx)
|
||
: -1;
|
||
(indexPos === undefined || ndxPos < indexPos) &&
|
||
-1 !== ndxPos &&
|
||
((bestMatch = lmnt), (indexPos = ndxPos));
|
||
}
|
||
),
|
||
bestMatch
|
||
? bestMatch.locator.slice(
|
||
(targetAlternation !== undefined
|
||
? targetAlternation
|
||
: bestMatch.alternation) + 1
|
||
)
|
||
: targetAlternation !== undefined
|
||
? resolveNdxInitializer(pos, alternateNdx)
|
||
: undefined
|
||
);
|
||
}
|
||
if (testPos > 1e4)
|
||
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. " +
|
||
getMaskSet().mask
|
||
);
|
||
if (testPos === pos && match.matches === undefined)
|
||
return (
|
||
matches.push({
|
||
match: match,
|
||
locator: loopNdx.reverse(),
|
||
cd: cacheDependency,
|
||
}),
|
||
!0
|
||
);
|
||
if (match.matches !== undefined) {
|
||
if (match.isGroup && quantifierRecurse !== match) {
|
||
if (
|
||
(match = handleMatch(
|
||
maskToken.matches[$.inArray(match, maskToken.matches) + 1],
|
||
loopNdx
|
||
))
|
||
)
|
||
return !0;
|
||
} else if (match.isOptional) {
|
||
var optionalToken = match;
|
||
if (
|
||
(match = resolveTestFromToken(
|
||
match,
|
||
ndxInitializer,
|
||
loopNdx,
|
||
quantifierRecurse
|
||
))
|
||
) {
|
||
if (
|
||
((latestMatch = matches[matches.length - 1].match),
|
||
!isFirstMatch(latestMatch, optionalToken))
|
||
)
|
||
return !0;
|
||
(insertStop = !0), (testPos = pos);
|
||
}
|
||
} else if (match.isAlternator) {
|
||
var maltMatches,
|
||
alternateToken = match,
|
||
malternateMatches = [],
|
||
currentMatches = matches.slice(),
|
||
loopNdxCnt = loopNdx.length,
|
||
altIndex =
|
||
ndxInitializer.length > 0 ? ndxInitializer.shift() : -1;
|
||
if (-1 === altIndex || "string" == typeof altIndex) {
|
||
var amndx,
|
||
currentPos = testPos,
|
||
ndxInitializerClone = ndxInitializer.slice(),
|
||
altIndexArr = [];
|
||
if ("string" == typeof altIndex)
|
||
altIndexArr = altIndex.split(",");
|
||
else
|
||
for (
|
||
amndx = 0;
|
||
amndx < alternateToken.matches.length;
|
||
amndx++
|
||
)
|
||
altIndexArr.push(amndx);
|
||
for (var ndx = 0; ndx < altIndexArr.length; ndx++) {
|
||
if (
|
||
((amndx = parseInt(altIndexArr[ndx])),
|
||
(matches = []),
|
||
(ndxInitializer =
|
||
resolveNdxInitializer(testPos, amndx, loopNdxCnt) ||
|
||
ndxInitializerClone.slice()),
|
||
!0 !==
|
||
(match =
|
||
handleMatch(
|
||
alternateToken.matches[amndx] ||
|
||
maskToken.matches[amndx],
|
||
[amndx].concat(loopNdx),
|
||
quantifierRecurse
|
||
) || match) &&
|
||
match !== undefined &&
|
||
altIndexArr[altIndexArr.length - 1] <
|
||
alternateToken.matches.length)
|
||
) {
|
||
var ntndx = $.inArray(match, maskToken.matches) + 1;
|
||
maskToken.matches.length > ntndx &&
|
||
(match = handleMatch(
|
||
maskToken.matches[ntndx],
|
||
[ntndx].concat(loopNdx.slice(1, loopNdx.length)),
|
||
quantifierRecurse
|
||
)) &&
|
||
(altIndexArr.push(ntndx.toString()),
|
||
$.each(matches, function (ndx, lmnt) {
|
||
lmnt.alternation = loopNdx.length - 1;
|
||
}));
|
||
}
|
||
(maltMatches = matches.slice()),
|
||
(testPos = currentPos),
|
||
(matches = []);
|
||
for (var ndx1 = 0; ndx1 < maltMatches.length; ndx1++) {
|
||
var altMatch = maltMatches[ndx1],
|
||
dropMatch = !1;
|
||
altMatch.alternation = altMatch.alternation || loopNdxCnt;
|
||
for (
|
||
var ndx2 = 0;
|
||
ndx2 < malternateMatches.length;
|
||
ndx2++
|
||
) {
|
||
var altMatch2 = malternateMatches[ndx2];
|
||
if (
|
||
"string" != typeof altIndex ||
|
||
-1 !==
|
||
$.inArray(
|
||
altMatch.locator[altMatch.alternation].toString(),
|
||
altIndexArr
|
||
)
|
||
) {
|
||
if (
|
||
(function (source, target) {
|
||
return (
|
||
source.match.nativeDef ===
|
||
target.match.nativeDef ||
|
||
source.match.def === target.match.nativeDef ||
|
||
source.match.nativeDef === target.match.def
|
||
);
|
||
})(altMatch, altMatch2)
|
||
) {
|
||
(dropMatch = !0),
|
||
altMatch.alternation === altMatch2.alternation &&
|
||
-1 ===
|
||
altMatch2.locator[altMatch2.alternation]
|
||
.toString()
|
||
.indexOf(
|
||
altMatch.locator[altMatch.alternation]
|
||
) &&
|
||
((altMatch2.locator[altMatch2.alternation] =
|
||
altMatch2.locator[altMatch2.alternation] +
|
||
"," +
|
||
altMatch.locator[altMatch.alternation]),
|
||
(altMatch2.alternation = altMatch.alternation)),
|
||
altMatch.match.nativeDef === altMatch2.match.def &&
|
||
((altMatch.locator[altMatch.alternation] =
|
||
altMatch2.locator[altMatch2.alternation]),
|
||
malternateMatches.splice(
|
||
malternateMatches.indexOf(altMatch2),
|
||
1,
|
||
altMatch
|
||
));
|
||
break;
|
||
}
|
||
if (altMatch.match.def === altMatch2.match.def) {
|
||
dropMatch = !1;
|
||
break;
|
||
}
|
||
if (
|
||
(function (source, target) {
|
||
return (
|
||
null === source.match.fn &&
|
||
null !== target.match.fn &&
|
||
target.match.fn.test(
|
||
source.match.def,
|
||
getMaskSet(),
|
||
pos,
|
||
!1,
|
||
opts,
|
||
!1
|
||
)
|
||
);
|
||
})(altMatch, altMatch2) ||
|
||
(function (source, target) {
|
||
return (
|
||
null !== source.match.fn &&
|
||
null !== target.match.fn &&
|
||
target.match.fn.test(
|
||
source.match.def.replace(/[\[\]]/g, ""),
|
||
getMaskSet(),
|
||
pos,
|
||
!1,
|
||
opts,
|
||
!1
|
||
)
|
||
);
|
||
})(altMatch, altMatch2)
|
||
) {
|
||
altMatch.alternation === altMatch2.alternation &&
|
||
-1 ===
|
||
altMatch.locator[altMatch.alternation]
|
||
.toString()
|
||
.indexOf(
|
||
altMatch2.locator[altMatch2.alternation]
|
||
.toString()
|
||
.split("")[0]
|
||
) &&
|
||
((altMatch.na =
|
||
altMatch.na ||
|
||
altMatch.locator[
|
||
altMatch.alternation
|
||
].toString()),
|
||
-1 ===
|
||
altMatch.na.indexOf(
|
||
altMatch.locator[altMatch.alternation]
|
||
.toString()
|
||
.split("")[0]
|
||
) &&
|
||
(altMatch.na =
|
||
altMatch.na +
|
||
"," +
|
||
altMatch.locator[altMatch2.alternation]
|
||
.toString()
|
||
.split("")[0]),
|
||
(dropMatch = !0),
|
||
(altMatch.locator[altMatch.alternation] =
|
||
altMatch2.locator[altMatch2.alternation]
|
||
.toString()
|
||
.split("")[0] +
|
||
"," +
|
||
altMatch.locator[altMatch.alternation]),
|
||
malternateMatches.splice(
|
||
malternateMatches.indexOf(altMatch2),
|
||
0,
|
||
altMatch
|
||
));
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
dropMatch || malternateMatches.push(altMatch);
|
||
}
|
||
}
|
||
"string" == typeof altIndex &&
|
||
(malternateMatches = $.map(
|
||
malternateMatches,
|
||
function (lmnt, ndx) {
|
||
if (isFinite(ndx)) {
|
||
var alternation = lmnt.alternation,
|
||
altLocArr = lmnt.locator[alternation]
|
||
.toString()
|
||
.split(",");
|
||
(lmnt.locator[alternation] = undefined),
|
||
(lmnt.alternation = undefined);
|
||
for (var alndx = 0; alndx < altLocArr.length; alndx++)
|
||
-1 !== $.inArray(altLocArr[alndx], altIndexArr) &&
|
||
(lmnt.locator[alternation] !== undefined
|
||
? ((lmnt.locator[alternation] += ","),
|
||
(lmnt.locator[alternation] += altLocArr[alndx]))
|
||
: (lmnt.locator[alternation] = parseInt(
|
||
altLocArr[alndx]
|
||
)),
|
||
(lmnt.alternation = alternation));
|
||
if (lmnt.locator[alternation] !== undefined)
|
||
return lmnt;
|
||
}
|
||
}
|
||
)),
|
||
(matches = currentMatches.concat(malternateMatches)),
|
||
(testPos = pos),
|
||
(insertStop = matches.length > 0),
|
||
(match = malternateMatches.length > 0),
|
||
(ndxInitializer = ndxInitializerClone.slice());
|
||
} else
|
||
match = handleMatch(
|
||
alternateToken.matches[altIndex] ||
|
||
maskToken.matches[altIndex],
|
||
[altIndex].concat(loopNdx),
|
||
quantifierRecurse
|
||
);
|
||
if (match) return !0;
|
||
} else if (
|
||
match.isQuantifier &&
|
||
quantifierRecurse !==
|
||
maskToken.matches[$.inArray(match, maskToken.matches) - 1]
|
||
)
|
||
for (
|
||
var qt = match,
|
||
qndx = ndxInitializer.length > 0 ? ndxInitializer.shift() : 0;
|
||
qndx <
|
||
(isNaN(qt.quantifier.max) ? qndx + 1 : qt.quantifier.max) &&
|
||
testPos <= pos;
|
||
qndx++
|
||
) {
|
||
var tokenGroup =
|
||
maskToken.matches[$.inArray(qt, maskToken.matches) - 1];
|
||
if (
|
||
(match = handleMatch(
|
||
tokenGroup,
|
||
[qndx].concat(loopNdx),
|
||
tokenGroup
|
||
))
|
||
) {
|
||
if (
|
||
((latestMatch = matches[matches.length - 1].match),
|
||
(latestMatch.optionalQuantifier =
|
||
qndx > qt.quantifier.min - 1),
|
||
isFirstMatch(latestMatch, tokenGroup))
|
||
) {
|
||
if (qndx > qt.quantifier.min - 1) {
|
||
(insertStop = !0), (testPos = pos);
|
||
break;
|
||
}
|
||
return !0;
|
||
}
|
||
return !0;
|
||
}
|
||
}
|
||
else if (
|
||
(match = resolveTestFromToken(
|
||
match,
|
||
ndxInitializer,
|
||
loopNdx,
|
||
quantifierRecurse
|
||
))
|
||
)
|
||
return !0;
|
||
} else testPos++;
|
||
}
|
||
for (
|
||
var tndx = ndxInitializer.length > 0 ? ndxInitializer.shift() : 0;
|
||
tndx < maskToken.matches.length;
|
||
tndx++
|
||
)
|
||
if (!0 !== maskToken.matches[tndx].isQuantifier) {
|
||
var match = handleMatch(
|
||
maskToken.matches[tndx],
|
||
[tndx].concat(loopNdx),
|
||
quantifierRecurse
|
||
);
|
||
if (match && testPos === pos) return match;
|
||
if (testPos > pos) break;
|
||
}
|
||
}
|
||
function filterTests(tests) {
|
||
if (
|
||
opts.keepStatic &&
|
||
pos > 0 &&
|
||
tests.length >
|
||
1 + ("" === tests[tests.length - 1].match.def ? 1 : 0) &&
|
||
!0 !== tests[0].match.optionality &&
|
||
!0 !== tests[0].match.optionalQuantifier &&
|
||
null === tests[0].match.fn &&
|
||
!/[0-9a-bA-Z]/.test(tests[0].match.def)
|
||
) {
|
||
if (getMaskSet().validPositions[pos - 1] === undefined)
|
||
return [determineTestTemplate(tests)];
|
||
if (
|
||
getMaskSet().validPositions[pos - 1].alternation ===
|
||
tests[0].alternation
|
||
)
|
||
return [determineTestTemplate(tests)];
|
||
if (getMaskSet().validPositions[pos - 1])
|
||
return [determineTestTemplate(tests)];
|
||
}
|
||
return tests;
|
||
}
|
||
var latestMatch,
|
||
maskTokens = getMaskSet().maskToken,
|
||
testPos = ndxIntlzr ? tstPs : 0,
|
||
ndxInitializer = ndxIntlzr ? ndxIntlzr.slice() : [0],
|
||
matches = [],
|
||
insertStop = !1,
|
||
cacheDependency = ndxIntlzr ? ndxIntlzr.join("") : "";
|
||
if (pos > -1) {
|
||
if (ndxIntlzr === undefined) {
|
||
for (
|
||
var test, previousPos = pos - 1;
|
||
(test =
|
||
getMaskSet().validPositions[previousPos] ||
|
||
getMaskSet().tests[previousPos]) === undefined &&
|
||
previousPos > -1;
|
||
|
||
)
|
||
previousPos--;
|
||
test !== undefined &&
|
||
previousPos > -1 &&
|
||
((ndxInitializer = (function (tests) {
|
||
var locator = [];
|
||
return (
|
||
$.isArray(tests) || (tests = [tests]),
|
||
tests.length > 0 &&
|
||
(tests[0].alternation === undefined
|
||
? 0 ===
|
||
(locator = determineTestTemplate(
|
||
tests.slice()
|
||
).locator.slice()).length &&
|
||
(locator = tests[0].locator.slice())
|
||
: $.each(tests, function (ndx, tst) {
|
||
if ("" !== tst.def)
|
||
if (0 === locator.length)
|
||
locator = tst.locator.slice();
|
||
else
|
||
for (var i = 0; i < locator.length; i++)
|
||
tst.locator[i] &&
|
||
-1 ===
|
||
locator[i]
|
||
.toString()
|
||
.indexOf(tst.locator[i]) &&
|
||
(locator[i] += "," + tst.locator[i]);
|
||
})),
|
||
locator
|
||
);
|
||
})(test)),
|
||
(cacheDependency = ndxInitializer.join("")),
|
||
(testPos = previousPos));
|
||
}
|
||
if (
|
||
getMaskSet().tests[pos] &&
|
||
getMaskSet().tests[pos][0].cd === cacheDependency
|
||
)
|
||
return filterTests(getMaskSet().tests[pos]);
|
||
for (
|
||
var mtndx = ndxInitializer.shift();
|
||
mtndx < maskTokens.length &&
|
||
!(
|
||
(resolveTestFromToken(maskTokens[mtndx], ndxInitializer, [mtndx]) &&
|
||
testPos === pos) ||
|
||
testPos > pos
|
||
);
|
||
mtndx++
|
||
);
|
||
}
|
||
return (
|
||
(0 === matches.length || insertStop) &&
|
||
matches.push({
|
||
match: {
|
||
fn: null,
|
||
cardinality: 0,
|
||
optionality: !0,
|
||
casing: null,
|
||
def: "",
|
||
placeholder: "",
|
||
},
|
||
locator: [],
|
||
cd: cacheDependency,
|
||
}),
|
||
ndxIntlzr !== undefined && getMaskSet().tests[pos]
|
||
? filterTests($.extend(!0, [], matches))
|
||
: ((getMaskSet().tests[pos] = $.extend(!0, [], matches)),
|
||
filterTests(getMaskSet().tests[pos]))
|
||
);
|
||
}
|
||
function getBufferTemplate() {
|
||
return (
|
||
getMaskSet()._buffer === undefined &&
|
||
((getMaskSet()._buffer = getMaskTemplate(!1, 1)),
|
||
getMaskSet().buffer === undefined &&
|
||
(getMaskSet().buffer = getMaskSet()._buffer.slice())),
|
||
getMaskSet()._buffer
|
||
);
|
||
}
|
||
function getBuffer(noCache) {
|
||
return (
|
||
(getMaskSet().buffer !== undefined && !0 !== noCache) ||
|
||
(getMaskSet().buffer = getMaskTemplate(
|
||
!0,
|
||
getLastValidPosition(),
|
||
!0
|
||
)),
|
||
getMaskSet().buffer
|
||
);
|
||
}
|
||
function refreshFromBuffer(start, end, buffer) {
|
||
var i, p;
|
||
if (!0 === start) resetMaskSet(), (start = 0), (end = buffer.length);
|
||
else for (i = start; i < end; i++) delete getMaskSet().validPositions[i];
|
||
for (p = start, i = start; i < end; i++)
|
||
if ((resetMaskSet(!0), buffer[i] !== opts.skipOptionalPartCharacter)) {
|
||
var valResult = isValid(p, buffer[i], !0, !0);
|
||
!1 !== valResult &&
|
||
(resetMaskSet(!0),
|
||
(p =
|
||
valResult.caret !== undefined
|
||
? valResult.caret
|
||
: valResult.pos + 1));
|
||
}
|
||
}
|
||
function casing(elem, test, pos) {
|
||
switch (opts.casing || test.casing) {
|
||
case "upper":
|
||
elem = elem.toUpperCase();
|
||
break;
|
||
|
||
case "lower":
|
||
elem = elem.toLowerCase();
|
||
break;
|
||
|
||
case "title":
|
||
var posBefore = getMaskSet().validPositions[pos - 1];
|
||
elem =
|
||
0 === pos ||
|
||
(posBefore &&
|
||
posBefore.input === String.fromCharCode(Inputmask.keyCode.SPACE))
|
||
? elem.toUpperCase()
|
||
: elem.toLowerCase();
|
||
break;
|
||
|
||
default:
|
||
if ($.isFunction(opts.casing)) {
|
||
var args = Array.prototype.slice.call(arguments);
|
||
args.push(getMaskSet().validPositions),
|
||
(elem = opts.casing.apply(this, args));
|
||
}
|
||
}
|
||
return elem;
|
||
}
|
||
function checkAlternationMatch(altArr1, altArr2, na) {
|
||
for (
|
||
var naNdx,
|
||
altArrC = opts.greedy ? altArr2 : altArr2.slice(0, 1),
|
||
isMatch = !1,
|
||
naArr = na !== undefined ? na.split(",") : [],
|
||
i = 0;
|
||
i < naArr.length;
|
||
i++
|
||
)
|
||
-1 !== (naNdx = altArr1.indexOf(naArr[i])) && altArr1.splice(naNdx, 1);
|
||
for (var alndx = 0; alndx < altArr1.length; alndx++)
|
||
if (-1 !== $.inArray(altArr1[alndx], altArrC)) {
|
||
isMatch = !0;
|
||
break;
|
||
}
|
||
return isMatch;
|
||
}
|
||
function isValid(
|
||
pos,
|
||
c,
|
||
strict,
|
||
fromSetValid,
|
||
fromAlternate,
|
||
validateOnly
|
||
) {
|
||
function isSelection(posObj) {
|
||
var selection = isRTL
|
||
? posObj.begin - posObj.end > 1 || posObj.begin - posObj.end == 1
|
||
: posObj.end - posObj.begin > 1 || posObj.end - posObj.begin == 1;
|
||
return selection &&
|
||
0 === posObj.begin &&
|
||
posObj.end === getMaskSet().maskLength
|
||
? "full"
|
||
: selection;
|
||
}
|
||
function _isValid(position, c, strict) {
|
||
var rslt = !1;
|
||
return (
|
||
$.each(getTests(position), function (ndx, tst) {
|
||
for (
|
||
var test = tst.match,
|
||
loopend = c ? 1 : 0,
|
||
chrs = "",
|
||
i = test.cardinality;
|
||
i > loopend;
|
||
i--
|
||
)
|
||
chrs += getBufferElement(position - (i - 1));
|
||
if (
|
||
(c && (chrs += c),
|
||
getBuffer(!0),
|
||
!1 !==
|
||
(rslt =
|
||
null != test.fn
|
||
? test.fn.test(
|
||
chrs,
|
||
getMaskSet(),
|
||
position,
|
||
strict,
|
||
opts,
|
||
isSelection(pos)
|
||
)
|
||
: (c === test.def ||
|
||
c === opts.skipOptionalPartCharacter) &&
|
||
"" !== test.def && {
|
||
c: getPlaceholder(position, test, !0) || test.def,
|
||
pos: position,
|
||
}))
|
||
) {
|
||
var elem = rslt.c !== undefined ? rslt.c : c;
|
||
elem =
|
||
elem === opts.skipOptionalPartCharacter && null === test.fn
|
||
? getPlaceholder(position, test, !0) || test.def
|
||
: elem;
|
||
var validatedPos = position,
|
||
possibleModifiedBuffer = getBuffer();
|
||
if (
|
||
(rslt.remove !== undefined &&
|
||
($.isArray(rslt.remove) || (rslt.remove = [rslt.remove]),
|
||
$.each(
|
||
rslt.remove.sort(function (a, b) {
|
||
return b - a;
|
||
}),
|
||
function (ndx, lmnt) {
|
||
stripValidPositions(lmnt, lmnt + 1, !0);
|
||
}
|
||
)),
|
||
rslt.insert !== undefined &&
|
||
($.isArray(rslt.insert) || (rslt.insert = [rslt.insert]),
|
||
$.each(
|
||
rslt.insert.sort(function (a, b) {
|
||
return a - b;
|
||
}),
|
||
function (ndx, lmnt) {
|
||
isValid(lmnt.pos, lmnt.c, !0, fromSetValid);
|
||
}
|
||
)),
|
||
rslt.refreshFromBuffer)
|
||
) {
|
||
var refresh = rslt.refreshFromBuffer;
|
||
if (
|
||
(refreshFromBuffer(
|
||
!0 === refresh ? refresh : refresh.start,
|
||
refresh.end,
|
||
possibleModifiedBuffer
|
||
),
|
||
rslt.pos === undefined && rslt.c === undefined)
|
||
)
|
||
return (rslt.pos = getLastValidPosition()), !1;
|
||
if (
|
||
(validatedPos =
|
||
rslt.pos !== undefined ? rslt.pos : position) !== position
|
||
)
|
||
return (
|
||
(rslt = $.extend(
|
||
rslt,
|
||
isValid(validatedPos, elem, !0, fromSetValid)
|
||
)),
|
||
!1
|
||
);
|
||
} else if (
|
||
!0 !== rslt &&
|
||
rslt.pos !== undefined &&
|
||
rslt.pos !== position &&
|
||
((validatedPos = rslt.pos),
|
||
refreshFromBuffer(position, validatedPos, getBuffer().slice()),
|
||
validatedPos !== position)
|
||
)
|
||
return (
|
||
(rslt = $.extend(rslt, isValid(validatedPos, elem, !0))), !1
|
||
);
|
||
return (
|
||
(!0 === rslt ||
|
||
rslt.pos !== undefined ||
|
||
rslt.c !== undefined) &&
|
||
(ndx > 0 && resetMaskSet(!0),
|
||
setValidPosition(
|
||
validatedPos,
|
||
$.extend({}, tst, {
|
||
input: casing(elem, test, validatedPos),
|
||
}),
|
||
fromSetValid,
|
||
isSelection(pos)
|
||
) || (rslt = !1),
|
||
!1)
|
||
);
|
||
}
|
||
}),
|
||
rslt
|
||
);
|
||
}
|
||
function setValidPosition(pos, validTest, fromSetValid, isSelection) {
|
||
if (
|
||
isSelection ||
|
||
(opts.insertMode &&
|
||
getMaskSet().validPositions[pos] !== undefined &&
|
||
fromSetValid === undefined)
|
||
) {
|
||
var i,
|
||
positionsClone = $.extend(!0, {}, getMaskSet().validPositions),
|
||
lvp = getLastValidPosition(undefined, !0);
|
||
for (i = pos; i <= lvp; i++) delete getMaskSet().validPositions[i];
|
||
getMaskSet().validPositions[pos] = $.extend(!0, {}, validTest);
|
||
var j,
|
||
valid = !0,
|
||
vps = getMaskSet().validPositions,
|
||
needsValidation = !1,
|
||
initialLength = getMaskSet().maskLength;
|
||
for (i = j = pos; i <= lvp; i++) {
|
||
var t = positionsClone[i];
|
||
if (t !== undefined)
|
||
for (
|
||
var posMatch = j;
|
||
posMatch < getMaskSet().maskLength &&
|
||
((null === t.match.fn &&
|
||
vps[i] &&
|
||
(!0 === vps[i].match.optionalQuantifier ||
|
||
!0 === vps[i].match.optionality)) ||
|
||
null != t.match.fn);
|
||
|
||
) {
|
||
if (
|
||
(posMatch++,
|
||
!1 === needsValidation &&
|
||
positionsClone[posMatch] &&
|
||
positionsClone[posMatch].match.def === t.match.def)
|
||
)
|
||
(getMaskSet().validPositions[posMatch] = $.extend(
|
||
!0,
|
||
{},
|
||
positionsClone[posMatch]
|
||
)),
|
||
(getMaskSet().validPositions[posMatch].input = t.input),
|
||
fillMissingNonMask(posMatch),
|
||
(j = posMatch),
|
||
(valid = !0);
|
||
else if (positionCanMatchDefinition(posMatch, t.match.def)) {
|
||
var result = isValid(posMatch, t.input, !0, !0);
|
||
(valid = !1 !== result),
|
||
(j =
|
||
result.caret || result.insert
|
||
? getLastValidPosition()
|
||
: posMatch),
|
||
(needsValidation = !0);
|
||
} else if (
|
||
!(valid = !0 === t.generatedInput) &&
|
||
posMatch >= getMaskSet().maskLength - 1
|
||
)
|
||
break;
|
||
if (
|
||
(getMaskSet().maskLength < initialLength &&
|
||
(getMaskSet().maskLength = initialLength),
|
||
valid)
|
||
)
|
||
break;
|
||
}
|
||
if (!valid) break;
|
||
}
|
||
if (!valid)
|
||
return (
|
||
(getMaskSet().validPositions = $.extend(!0, {}, positionsClone)),
|
||
resetMaskSet(!0),
|
||
!1
|
||
);
|
||
} else getMaskSet().validPositions[pos] = $.extend(!0, {}, validTest);
|
||
return resetMaskSet(!0), !0;
|
||
}
|
||
function fillMissingNonMask(maskPos) {
|
||
for (
|
||
var pndx = maskPos - 1;
|
||
pndx > -1 && !getMaskSet().validPositions[pndx];
|
||
pndx--
|
||
);
|
||
var testTemplate, testsFromPos;
|
||
for (pndx++; pndx < maskPos; pndx++)
|
||
getMaskSet().validPositions[pndx] === undefined &&
|
||
(!1 === opts.jitMasking || opts.jitMasking > pndx) &&
|
||
("" ===
|
||
(testsFromPos = getTests(
|
||
pndx,
|
||
getTestTemplate(pndx - 1).locator,
|
||
pndx - 1
|
||
).slice())[testsFromPos.length - 1].match.def &&
|
||
testsFromPos.pop(),
|
||
(testTemplate = determineTestTemplate(testsFromPos)) &&
|
||
(testTemplate.match.def === opts.radixPointDefinitionSymbol ||
|
||
!isMask(pndx, !0) ||
|
||
($.inArray(opts.radixPoint, getBuffer()) < pndx &&
|
||
testTemplate.match.fn &&
|
||
testTemplate.match.fn.test(
|
||
getPlaceholder(pndx),
|
||
getMaskSet(),
|
||
pndx,
|
||
!1,
|
||
opts
|
||
))) &&
|
||
!1 !==
|
||
(result = _isValid(
|
||
pndx,
|
||
getPlaceholder(pndx, testTemplate.match, !0) ||
|
||
(null == testTemplate.match.fn
|
||
? testTemplate.match.def
|
||
: "" !== getPlaceholder(pndx)
|
||
? getPlaceholder(pndx)
|
||
: getBuffer()[pndx]),
|
||
!0
|
||
)) &&
|
||
(getMaskSet().validPositions[result.pos || pndx].generatedInput =
|
||
!0));
|
||
}
|
||
strict = !0 === strict;
|
||
var maskPos = pos;
|
||
pos.begin !== undefined &&
|
||
(maskPos = isRTL && !isSelection(pos) ? pos.end : pos.begin);
|
||
var result = !0,
|
||
positionsClone = $.extend(!0, {}, getMaskSet().validPositions);
|
||
if (
|
||
($.isFunction(opts.preValidation) &&
|
||
!strict &&
|
||
!0 !== fromSetValid &&
|
||
!0 !== validateOnly &&
|
||
(result = opts.preValidation(
|
||
getBuffer(),
|
||
maskPos,
|
||
c,
|
||
isSelection(pos),
|
||
opts
|
||
)),
|
||
!0 === result)
|
||
) {
|
||
if (
|
||
(fillMissingNonMask(maskPos),
|
||
isSelection(pos) &&
|
||
(handleRemove(undefined, Inputmask.keyCode.DELETE, pos, !0, !0),
|
||
(maskPos = getMaskSet().p)),
|
||
maskPos < getMaskSet().maskLength &&
|
||
(maxLength === undefined || maskPos < maxLength) &&
|
||
((result = _isValid(maskPos, c, strict)),
|
||
(!strict || !0 === fromSetValid) &&
|
||
!1 === result &&
|
||
!0 !== validateOnly))
|
||
) {
|
||
var currentPosValid = getMaskSet().validPositions[maskPos];
|
||
if (
|
||
!currentPosValid ||
|
||
null !== currentPosValid.match.fn ||
|
||
(currentPosValid.match.def !== c &&
|
||
c !== opts.skipOptionalPartCharacter)
|
||
) {
|
||
if (
|
||
(opts.insertMode ||
|
||
getMaskSet().validPositions[seekNext(maskPos)] === undefined) &&
|
||
!isMask(maskPos, !0)
|
||
)
|
||
for (
|
||
var nPos = maskPos + 1, snPos = seekNext(maskPos);
|
||
nPos <= snPos;
|
||
nPos++
|
||
)
|
||
if (!1 !== (result = _isValid(nPos, c, strict))) {
|
||
!(function (originalPos, newPos) {
|
||
var vp = getMaskSet().validPositions[newPos];
|
||
if (vp)
|
||
for (
|
||
var targetLocator = vp.locator,
|
||
tll = targetLocator.length,
|
||
ps = originalPos;
|
||
ps < newPos;
|
||
ps++
|
||
)
|
||
if (
|
||
getMaskSet().validPositions[ps] === undefined &&
|
||
!isMask(ps, !0)
|
||
) {
|
||
var tests = getTests(ps).slice(),
|
||
bestMatch = determineTestTemplate(tests, !0),
|
||
equality = -1;
|
||
"" === tests[tests.length - 1].match.def &&
|
||
tests.pop(),
|
||
$.each(tests, function (ndx, tst) {
|
||
for (var i = 0; i < tll; i++) {
|
||
if (
|
||
tst.locator[i] === undefined ||
|
||
!checkAlternationMatch(
|
||
tst.locator[i].toString().split(","),
|
||
targetLocator[i].toString().split(","),
|
||
tst.na
|
||
)
|
||
) {
|
||
var targetAI = targetLocator[i],
|
||
bestMatchAI = bestMatch.locator[i],
|
||
tstAI = tst.locator[i];
|
||
targetAI - bestMatchAI >
|
||
Math.abs(targetAI - tstAI) &&
|
||
(bestMatch = tst);
|
||
break;
|
||
}
|
||
equality < i &&
|
||
((equality = i), (bestMatch = tst));
|
||
}
|
||
}),
|
||
((bestMatch = $.extend({}, bestMatch, {
|
||
input:
|
||
getPlaceholder(ps, bestMatch.match, !0) ||
|
||
bestMatch.match.def,
|
||
})).generatedInput = !0),
|
||
setValidPosition(ps, bestMatch, !0),
|
||
(getMaskSet().validPositions[newPos] = undefined),
|
||
_isValid(newPos, vp.input, !0);
|
||
}
|
||
})(maskPos, result.pos !== undefined ? result.pos : nPos),
|
||
(maskPos = nPos);
|
||
break;
|
||
}
|
||
} else
|
||
result = {
|
||
caret: seekNext(maskPos),
|
||
};
|
||
}
|
||
!1 === result &&
|
||
opts.keepStatic &&
|
||
!strict &&
|
||
!0 !== fromAlternate &&
|
||
(result = (function (pos, c, strict) {
|
||
var lastAlt,
|
||
alternation,
|
||
altPos,
|
||
prevAltPos,
|
||
i,
|
||
validPos,
|
||
altNdxs,
|
||
decisionPos,
|
||
validPsClone = $.extend(!0, {}, getMaskSet().validPositions),
|
||
isValidRslt = !1,
|
||
lAltPos = getLastValidPosition();
|
||
for (
|
||
prevAltPos = getMaskSet().validPositions[lAltPos];
|
||
lAltPos >= 0;
|
||
lAltPos--
|
||
)
|
||
if (
|
||
(altPos = getMaskSet().validPositions[lAltPos]) &&
|
||
altPos.alternation !== undefined
|
||
) {
|
||
if (
|
||
((lastAlt = lAltPos),
|
||
(alternation =
|
||
getMaskSet().validPositions[lastAlt].alternation),
|
||
prevAltPos.locator[altPos.alternation] !==
|
||
altPos.locator[altPos.alternation])
|
||
)
|
||
break;
|
||
prevAltPos = altPos;
|
||
}
|
||
if (alternation !== undefined) {
|
||
decisionPos = parseInt(lastAlt);
|
||
var decisionTaker =
|
||
prevAltPos.locator[prevAltPos.alternation || alternation] !==
|
||
undefined
|
||
? prevAltPos.locator[prevAltPos.alternation || alternation]
|
||
: altNdxs[0];
|
||
decisionTaker.length > 0 &&
|
||
(decisionTaker = decisionTaker.split(",")[0]);
|
||
var possibilityPos = getMaskSet().validPositions[decisionPos],
|
||
prevPos = getMaskSet().validPositions[decisionPos - 1];
|
||
$.each(
|
||
getTests(
|
||
decisionPos,
|
||
prevPos ? prevPos.locator : undefined,
|
||
decisionPos - 1
|
||
),
|
||
function (ndx, test) {
|
||
altNdxs = test.locator[alternation]
|
||
? test.locator[alternation].toString().split(",")
|
||
: [];
|
||
for (var mndx = 0; mndx < altNdxs.length; mndx++) {
|
||
var validInputs = [],
|
||
staticInputsBeforePos = 0,
|
||
staticInputsBeforePosAlternate = 0,
|
||
verifyValidInput = !1;
|
||
if (
|
||
decisionTaker < altNdxs[mndx] &&
|
||
(test.na === undefined ||
|
||
-1 === $.inArray(altNdxs[mndx], test.na.split(",")) ||
|
||
-1 === $.inArray(decisionTaker.toString(), altNdxs))
|
||
) {
|
||
getMaskSet().validPositions[decisionPos] = $.extend(
|
||
!0,
|
||
{},
|
||
test
|
||
);
|
||
var possibilities =
|
||
getMaskSet().validPositions[decisionPos].locator;
|
||
for (
|
||
getMaskSet().validPositions[decisionPos].locator[
|
||
alternation
|
||
] = parseInt(altNdxs[mndx]),
|
||
null == test.match.fn
|
||
? (possibilityPos.input !== test.match.def &&
|
||
((verifyValidInput = !0),
|
||
!0 !== possibilityPos.generatedInput &&
|
||
validInputs.push(possibilityPos.input)),
|
||
staticInputsBeforePosAlternate++,
|
||
(getMaskSet().validPositions[
|
||
decisionPos
|
||
].generatedInput = !/[0-9a-bA-Z]/.test(
|
||
test.match.def
|
||
)),
|
||
(getMaskSet().validPositions[decisionPos].input =
|
||
test.match.def))
|
||
: (getMaskSet().validPositions[decisionPos].input =
|
||
possibilityPos.input),
|
||
i = decisionPos + 1;
|
||
i < getLastValidPosition(undefined, !0) + 1;
|
||
i++
|
||
)
|
||
(validPos = getMaskSet().validPositions[i]) &&
|
||
!0 !== validPos.generatedInput &&
|
||
/[0-9a-bA-Z]/.test(validPos.input)
|
||
? validInputs.push(validPos.input)
|
||
: i < pos && staticInputsBeforePos++,
|
||
delete getMaskSet().validPositions[i];
|
||
for (
|
||
verifyValidInput &&
|
||
validInputs[0] === test.match.def &&
|
||
validInputs.shift(),
|
||
resetMaskSet(!0),
|
||
isValidRslt = !0;
|
||
validInputs.length > 0;
|
||
|
||
) {
|
||
var input = validInputs.shift();
|
||
if (
|
||
input !== opts.skipOptionalPartCharacter &&
|
||
!(isValidRslt = isValid(
|
||
getLastValidPosition(undefined, !0) + 1,
|
||
input,
|
||
!1,
|
||
fromSetValid,
|
||
!0
|
||
))
|
||
)
|
||
break;
|
||
}
|
||
if (isValidRslt) {
|
||
getMaskSet().validPositions[decisionPos].locator =
|
||
possibilities;
|
||
var targetLvp = getLastValidPosition(pos) + 1;
|
||
for (
|
||
i = decisionPos + 1;
|
||
i < getLastValidPosition() + 1;
|
||
i++
|
||
)
|
||
((validPos = getMaskSet().validPositions[i]) ===
|
||
undefined ||
|
||
null == validPos.match.fn) &&
|
||
i <
|
||
pos +
|
||
(staticInputsBeforePosAlternate -
|
||
staticInputsBeforePos) &&
|
||
staticInputsBeforePosAlternate++;
|
||
isValidRslt = isValid(
|
||
(pos +=
|
||
staticInputsBeforePosAlternate -
|
||
staticInputsBeforePos) > targetLvp
|
||
? targetLvp
|
||
: pos,
|
||
c,
|
||
strict,
|
||
fromSetValid,
|
||
!0
|
||
);
|
||
}
|
||
if (isValidRslt) return !1;
|
||
resetMaskSet(),
|
||
(getMaskSet().validPositions = $.extend(
|
||
!0,
|
||
{},
|
||
validPsClone
|
||
));
|
||
}
|
||
}
|
||
}
|
||
);
|
||
}
|
||
return isValidRslt;
|
||
})(maskPos, c, strict)),
|
||
!0 === result &&
|
||
(result = {
|
||
pos: maskPos,
|
||
});
|
||
}
|
||
if (
|
||
$.isFunction(opts.postValidation) &&
|
||
!1 !== result &&
|
||
!strict &&
|
||
!0 !== fromSetValid &&
|
||
!0 !== validateOnly
|
||
) {
|
||
var postResult = opts.postValidation(getBuffer(!0), result, opts);
|
||
if (postResult.refreshFromBuffer && postResult.buffer) {
|
||
var refresh = postResult.refreshFromBuffer;
|
||
refreshFromBuffer(
|
||
!0 === refresh ? refresh : refresh.start,
|
||
refresh.end,
|
||
postResult.buffer
|
||
);
|
||
}
|
||
result = !0 === postResult ? result : postResult;
|
||
}
|
||
return (
|
||
result && result.pos === undefined && (result.pos = maskPos),
|
||
(!1 !== result && !0 !== validateOnly) ||
|
||
(resetMaskSet(!0),
|
||
(getMaskSet().validPositions = $.extend(!0, {}, positionsClone))),
|
||
result
|
||
);
|
||
}
|
||
function isMask(pos, strict) {
|
||
var test = getTestTemplate(pos).match;
|
||
if (("" === test.def && (test = getTest(pos).match), null != test.fn))
|
||
return test.fn;
|
||
if (!0 !== strict && pos > -1) {
|
||
var tests = getTests(pos);
|
||
return (
|
||
tests.length > 1 + ("" === tests[tests.length - 1].match.def ? 1 : 0)
|
||
);
|
||
}
|
||
return !1;
|
||
}
|
||
function seekNext(pos, newBlock) {
|
||
var maskL = getMaskSet().maskLength;
|
||
if (pos >= maskL) return maskL;
|
||
var position = pos;
|
||
for (
|
||
getTests(maskL + 1).length > 1 &&
|
||
(getMaskTemplate(!0, maskL + 1, !0), (maskL = getMaskSet().maskLength));
|
||
++position < maskL &&
|
||
((!0 === newBlock &&
|
||
(!0 !== getTest(position).match.newBlockMarker ||
|
||
!isMask(position))) ||
|
||
(!0 !== newBlock && !isMask(position)));
|
||
|
||
);
|
||
return position;
|
||
}
|
||
function seekPrevious(pos, newBlock) {
|
||
var tests,
|
||
position = pos;
|
||
if (position <= 0) return 0;
|
||
for (
|
||
;
|
||
--position > 0 &&
|
||
((!0 === newBlock && !0 !== getTest(position).match.newBlockMarker) ||
|
||
(!0 !== newBlock &&
|
||
!isMask(position) &&
|
||
((tests = getTests(position)).length < 2 ||
|
||
(2 === tests.length && "" === tests[1].match.def))));
|
||
|
||
);
|
||
return position;
|
||
}
|
||
function getBufferElement(position) {
|
||
return getMaskSet().validPositions[position] === undefined
|
||
? getPlaceholder(position)
|
||
: getMaskSet().validPositions[position].input;
|
||
}
|
||
function writeBuffer(input, buffer, caretPos, event, triggerInputEvent) {
|
||
if (event && $.isFunction(opts.onBeforeWrite)) {
|
||
var result = opts.onBeforeWrite.call(
|
||
inputmask,
|
||
event,
|
||
buffer,
|
||
caretPos,
|
||
opts
|
||
);
|
||
if (result) {
|
||
if (result.refreshFromBuffer) {
|
||
var refresh = result.refreshFromBuffer;
|
||
refreshFromBuffer(
|
||
!0 === refresh ? refresh : refresh.start,
|
||
refresh.end,
|
||
result.buffer || buffer
|
||
),
|
||
(buffer = getBuffer(!0));
|
||
}
|
||
caretPos !== undefined &&
|
||
(caretPos = result.caret !== undefined ? result.caret : caretPos);
|
||
}
|
||
}
|
||
input !== undefined &&
|
||
(input.inputmask._valueSet(buffer.join("")),
|
||
caretPos === undefined || (event !== undefined && "blur" === event.type)
|
||
? renderColorMask(input, caretPos, 0 === buffer.length)
|
||
: android && event && "input" === event.type
|
||
? setTimeout(function () {
|
||
caret(input, caretPos);
|
||
}, 0)
|
||
: caret(input, caretPos),
|
||
!0 === triggerInputEvent &&
|
||
((skipInputEvent = !0), $(input).trigger("input")));
|
||
}
|
||
function getPlaceholder(pos, test, returnPL) {
|
||
if (
|
||
(test = test || getTest(pos).match).placeholder !== undefined ||
|
||
!0 === returnPL
|
||
)
|
||
return $.isFunction(test.placeholder)
|
||
? test.placeholder(opts)
|
||
: test.placeholder;
|
||
if (null === test.fn) {
|
||
if (pos > -1 && getMaskSet().validPositions[pos] === undefined) {
|
||
var prevTest,
|
||
tests = getTests(pos),
|
||
staticAlternations = [];
|
||
if (
|
||
tests.length >
|
||
1 + ("" === tests[tests.length - 1].match.def ? 1 : 0)
|
||
)
|
||
for (var i = 0; i < tests.length; i++)
|
||
if (
|
||
!0 !== tests[i].match.optionality &&
|
||
!0 !== tests[i].match.optionalQuantifier &&
|
||
(null === tests[i].match.fn ||
|
||
prevTest === undefined ||
|
||
!1 !==
|
||
tests[i].match.fn.test(
|
||
prevTest.match.def,
|
||
getMaskSet(),
|
||
pos,
|
||
!0,
|
||
opts
|
||
)) &&
|
||
(staticAlternations.push(tests[i]),
|
||
null === tests[i].match.fn && (prevTest = tests[i]),
|
||
staticAlternations.length > 1 &&
|
||
/[0-9a-bA-Z]/.test(staticAlternations[0].match.def))
|
||
)
|
||
return opts.placeholder.charAt(pos % opts.placeholder.length);
|
||
}
|
||
return test.def;
|
||
}
|
||
return opts.placeholder.charAt(pos % opts.placeholder.length);
|
||
}
|
||
function checkVal(input, writeOut, strict, nptvl, initiatingEvent) {
|
||
function isTemplateMatch(ndx, charCodes) {
|
||
return (
|
||
-1 !==
|
||
getBufferTemplate()
|
||
.slice(ndx, seekNext(ndx))
|
||
.join("")
|
||
.indexOf(charCodes) &&
|
||
!isMask(ndx) &&
|
||
getTest(ndx).match.nativeDef ===
|
||
charCodes.charAt(charCodes.length - 1)
|
||
);
|
||
}
|
||
var inputValue = nptvl.slice(),
|
||
charCodes = "",
|
||
initialNdx = -1,
|
||
result = undefined;
|
||
if ((resetMaskSet(), strict || !0 === opts.autoUnmask))
|
||
initialNdx = seekNext(initialNdx);
|
||
else {
|
||
var staticInput = getBufferTemplate().slice(0, seekNext(-1)).join(""),
|
||
matches = inputValue
|
||
.join("")
|
||
.match(new RegExp("^" + Inputmask.escapeRegex(staticInput), "g"));
|
||
matches &&
|
||
matches.length > 0 &&
|
||
(inputValue.splice(0, matches.length * staticInput.length),
|
||
(initialNdx = seekNext(initialNdx)));
|
||
}
|
||
if (
|
||
(-1 === initialNdx
|
||
? ((getMaskSet().p = seekNext(initialNdx)), (initialNdx = 0))
|
||
: (getMaskSet().p = initialNdx),
|
||
$.each(inputValue, function (ndx, charCode) {
|
||
if (charCode !== undefined)
|
||
if (
|
||
getMaskSet().validPositions[ndx] === undefined &&
|
||
inputValue[ndx] === getPlaceholder(ndx) &&
|
||
isMask(ndx, !0) &&
|
||
!1 === isValid(ndx, inputValue[ndx], !0, undefined, undefined, !0)
|
||
)
|
||
getMaskSet().p++;
|
||
else {
|
||
var keypress = new $.Event("_checkval");
|
||
(keypress.which = charCode.charCodeAt(0)),
|
||
(charCodes += charCode);
|
||
var lvp = getLastValidPosition(undefined, !0),
|
||
lvTest = getMaskSet().validPositions[lvp],
|
||
nextTest = getTestTemplate(
|
||
lvp + 1,
|
||
lvTest ? lvTest.locator.slice() : undefined,
|
||
lvp
|
||
);
|
||
if (
|
||
!isTemplateMatch(initialNdx, charCodes) ||
|
||
strict ||
|
||
opts.autoUnmask
|
||
) {
|
||
var pos = strict
|
||
? ndx
|
||
: null == nextTest.match.fn &&
|
||
nextTest.match.optionality &&
|
||
lvp + 1 < getMaskSet().p
|
||
? lvp + 1
|
||
: getMaskSet().p;
|
||
(result = EventHandlers.keypressEvent.call(
|
||
input,
|
||
keypress,
|
||
!0,
|
||
!1,
|
||
strict,
|
||
pos
|
||
)),
|
||
(initialNdx = pos + 1),
|
||
(charCodes = "");
|
||
} else
|
||
result = EventHandlers.keypressEvent.call(
|
||
input,
|
||
keypress,
|
||
!0,
|
||
!1,
|
||
!0,
|
||
lvp + 1
|
||
);
|
||
if (
|
||
!1 !== result &&
|
||
!strict &&
|
||
$.isFunction(opts.onBeforeWrite)
|
||
) {
|
||
var origResult = result;
|
||
if (
|
||
((result = opts.onBeforeWrite.call(
|
||
inputmask,
|
||
keypress,
|
||
getBuffer(),
|
||
result.forwardPosition,
|
||
opts
|
||
)),
|
||
(result = $.extend(origResult, result)) &&
|
||
result.refreshFromBuffer)
|
||
) {
|
||
var refresh = result.refreshFromBuffer;
|
||
refreshFromBuffer(
|
||
!0 === refresh ? refresh : refresh.start,
|
||
refresh.end,
|
||
result.buffer
|
||
),
|
||
resetMaskSet(!0),
|
||
result.caret &&
|
||
((getMaskSet().p = result.caret),
|
||
(result.forwardPosition = result.caret));
|
||
}
|
||
}
|
||
}
|
||
}),
|
||
writeOut)
|
||
) {
|
||
var caretPos = undefined;
|
||
document.activeElement === input &&
|
||
result &&
|
||
(caretPos = opts.numericInput
|
||
? seekPrevious(result.forwardPosition)
|
||
: result.forwardPosition),
|
||
writeBuffer(
|
||
input,
|
||
getBuffer(),
|
||
caretPos,
|
||
initiatingEvent || new $.Event("checkval"),
|
||
initiatingEvent && "input" === initiatingEvent.type
|
||
);
|
||
}
|
||
}
|
||
function unmaskedvalue(input) {
|
||
if (input) {
|
||
if (input.inputmask === undefined) return input.value;
|
||
input.inputmask &&
|
||
input.inputmask.refreshValue &&
|
||
EventHandlers.setValueEvent.call(input);
|
||
}
|
||
var umValue = [],
|
||
vps = getMaskSet().validPositions;
|
||
for (var pndx in vps)
|
||
vps[pndx].match &&
|
||
null != vps[pndx].match.fn &&
|
||
umValue.push(vps[pndx].input);
|
||
var unmaskedValue =
|
||
0 === umValue.length
|
||
? ""
|
||
: (isRTL ? umValue.reverse() : umValue).join("");
|
||
if ($.isFunction(opts.onUnMask)) {
|
||
var bufferValue = (
|
||
isRTL ? getBuffer().slice().reverse() : getBuffer()
|
||
).join("");
|
||
unmaskedValue = opts.onUnMask.call(
|
||
inputmask,
|
||
bufferValue,
|
||
unmaskedValue,
|
||
opts
|
||
);
|
||
}
|
||
return unmaskedValue;
|
||
}
|
||
function caret(input, begin, end, notranslate) {
|
||
function translatePosition(pos) {
|
||
return (
|
||
!0 === notranslate ||
|
||
!isRTL ||
|
||
"number" != typeof pos ||
|
||
(opts.greedy && "" === opts.placeholder) ||
|
||
(pos = getBuffer().join("").length - pos),
|
||
pos
|
||
);
|
||
}
|
||
var range;
|
||
if (begin === undefined)
|
||
return (
|
||
input.setSelectionRange
|
||
? ((begin = input.selectionStart), (end = input.selectionEnd))
|
||
: window.getSelection
|
||
? ((range = window.getSelection().getRangeAt(0))
|
||
.commonAncestorContainer.parentNode !== input &&
|
||
range.commonAncestorContainer !== input) ||
|
||
((begin = range.startOffset), (end = range.endOffset))
|
||
: document.selection &&
|
||
document.selection.createRange &&
|
||
(end =
|
||
(begin =
|
||
0 -
|
||
(range = document.selection.createRange())
|
||
.duplicate()
|
||
.moveStart(
|
||
"character",
|
||
-input.inputmask._valueGet().length
|
||
)) + range.text.length),
|
||
{
|
||
begin: translatePosition(begin),
|
||
end: translatePosition(end),
|
||
}
|
||
);
|
||
if (
|
||
(begin.begin !== undefined &&
|
||
((end = begin.end), (begin = begin.begin)),
|
||
"number" == typeof begin)
|
||
) {
|
||
(begin = translatePosition(begin)),
|
||
(end =
|
||
"number" == typeof (end = translatePosition(end)) ? end : begin);
|
||
var scrollCalc =
|
||
parseInt(
|
||
((input.ownerDocument.defaultView || window).getComputedStyle
|
||
? (input.ownerDocument.defaultView || window).getComputedStyle(
|
||
input,
|
||
null
|
||
)
|
||
: input.currentStyle
|
||
).fontSize
|
||
) * end;
|
||
if (
|
||
((input.scrollLeft = scrollCalc > input.scrollWidth ? scrollCalc : 0),
|
||
mobile || !1 !== opts.insertMode || begin !== end || end++,
|
||
input.setSelectionRange)
|
||
)
|
||
(input.selectionStart = begin), (input.selectionEnd = end);
|
||
else if (window.getSelection) {
|
||
if (
|
||
((range = document.createRange()),
|
||
input.firstChild === undefined || null === input.firstChild)
|
||
) {
|
||
var textNode = document.createTextNode("");
|
||
input.appendChild(textNode);
|
||
}
|
||
range.setStart(
|
||
input.firstChild,
|
||
begin < input.inputmask._valueGet().length
|
||
? begin
|
||
: input.inputmask._valueGet().length
|
||
),
|
||
range.setEnd(
|
||
input.firstChild,
|
||
end < input.inputmask._valueGet().length
|
||
? end
|
||
: input.inputmask._valueGet().length
|
||
),
|
||
range.collapse(!0);
|
||
var sel = window.getSelection();
|
||
sel.removeAllRanges(), sel.addRange(range);
|
||
} else
|
||
input.createTextRange &&
|
||
((range = input.createTextRange()).collapse(!0),
|
||
range.moveEnd("character", end),
|
||
range.moveStart("character", begin),
|
||
range.select());
|
||
renderColorMask(input, {
|
||
begin: begin,
|
||
end: end,
|
||
});
|
||
}
|
||
}
|
||
function determineLastRequiredPosition(returnDefinition) {
|
||
var pos,
|
||
testPos,
|
||
buffer = getBuffer(),
|
||
bl = buffer.length,
|
||
lvp = getLastValidPosition(),
|
||
positions = {},
|
||
lvTest = getMaskSet().validPositions[lvp],
|
||
ndxIntlzr = lvTest !== undefined ? lvTest.locator.slice() : undefined;
|
||
for (pos = lvp + 1; pos < buffer.length; pos++)
|
||
(ndxIntlzr = (testPos = getTestTemplate(
|
||
pos,
|
||
ndxIntlzr,
|
||
pos - 1
|
||
)).locator.slice()),
|
||
(positions[pos] = $.extend(!0, {}, testPos));
|
||
var lvTestAlt =
|
||
lvTest && lvTest.alternation !== undefined
|
||
? lvTest.locator[lvTest.alternation]
|
||
: undefined;
|
||
for (
|
||
pos = bl - 1;
|
||
pos > lvp &&
|
||
((testPos = positions[pos]).match.optionality ||
|
||
(testPos.match.optionalQuantifier && testPos.match.newBlockMarker) ||
|
||
(lvTestAlt &&
|
||
((lvTestAlt !== positions[pos].locator[lvTest.alternation] &&
|
||
null != testPos.match.fn) ||
|
||
(null === testPos.match.fn &&
|
||
testPos.locator[lvTest.alternation] &&
|
||
checkAlternationMatch(
|
||
testPos.locator[lvTest.alternation].toString().split(","),
|
||
lvTestAlt.toString().split(",")
|
||
) &&
|
||
"" !== getTests(pos)[0].def)))) &&
|
||
buffer[pos] === getPlaceholder(pos, testPos.match);
|
||
pos--
|
||
)
|
||
bl--;
|
||
return returnDefinition
|
||
? {
|
||
l: bl,
|
||
def: positions[bl] ? positions[bl].match : undefined,
|
||
}
|
||
: bl;
|
||
}
|
||
function clearOptionalTail(buffer) {
|
||
for (
|
||
var validPos,
|
||
rl = determineLastRequiredPosition(),
|
||
bl = buffer.length,
|
||
lv = getMaskSet().validPositions[getLastValidPosition()];
|
||
rl < bl &&
|
||
!isMask(rl, !0) &&
|
||
(validPos =
|
||
lv !== undefined
|
||
? getTestTemplate(rl, lv.locator.slice(""), lv)
|
||
: getTest(rl)) &&
|
||
!0 !== validPos.match.optionality &&
|
||
((!0 !== validPos.match.optionalQuantifier &&
|
||
!0 !== validPos.match.newBlockMarker) ||
|
||
(rl + 1 === bl &&
|
||
"" ===
|
||
(lv !== undefined
|
||
? getTestTemplate(rl + 1, lv.locator.slice(""), lv)
|
||
: getTest(rl + 1)
|
||
).match.def));
|
||
|
||
)
|
||
rl++;
|
||
for (
|
||
;
|
||
(validPos = getMaskSet().validPositions[rl - 1]) &&
|
||
validPos &&
|
||
validPos.match.optionality &&
|
||
validPos.input === opts.skipOptionalPartCharacter;
|
||
|
||
)
|
||
rl--;
|
||
return buffer.splice(rl), buffer;
|
||
}
|
||
function isComplete(buffer) {
|
||
if ($.isFunction(opts.isComplete)) return opts.isComplete(buffer, opts);
|
||
if ("*" === opts.repeat) return undefined;
|
||
var complete = !1,
|
||
lrp = determineLastRequiredPosition(!0),
|
||
aml = seekPrevious(lrp.l);
|
||
if (
|
||
lrp.def === undefined ||
|
||
lrp.def.newBlockMarker ||
|
||
lrp.def.optionality ||
|
||
lrp.def.optionalQuantifier
|
||
) {
|
||
complete = !0;
|
||
for (var i = 0; i <= aml; i++) {
|
||
var test = getTestTemplate(i).match;
|
||
if (
|
||
(null !== test.fn &&
|
||
getMaskSet().validPositions[i] === undefined &&
|
||
!0 !== test.optionality &&
|
||
!0 !== test.optionalQuantifier) ||
|
||
(null === test.fn && buffer[i] !== getPlaceholder(i, test))
|
||
) {
|
||
complete = !1;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
return complete;
|
||
}
|
||
function handleRemove(input, k, pos, strict, fromIsValid) {
|
||
if (
|
||
(opts.numericInput || isRTL) &&
|
||
(k === Inputmask.keyCode.BACKSPACE
|
||
? (k = Inputmask.keyCode.DELETE)
|
||
: k === Inputmask.keyCode.DELETE && (k = Inputmask.keyCode.BACKSPACE),
|
||
isRTL)
|
||
) {
|
||
var pend = pos.end;
|
||
(pos.end = pos.begin), (pos.begin = pend);
|
||
}
|
||
k === Inputmask.keyCode.BACKSPACE &&
|
||
(pos.end - pos.begin < 1 || !1 === opts.insertMode)
|
||
? ((pos.begin = seekPrevious(pos.begin)),
|
||
getMaskSet().validPositions[pos.begin] !== undefined &&
|
||
getMaskSet().validPositions[pos.begin].input ===
|
||
opts.groupSeparator &&
|
||
pos.begin--)
|
||
: k === Inputmask.keyCode.DELETE &&
|
||
pos.begin === pos.end &&
|
||
((pos.end =
|
||
isMask(pos.end, !0) &&
|
||
getMaskSet().validPositions[pos.end] &&
|
||
getMaskSet().validPositions[pos.end].input !== opts.radixPoint
|
||
? pos.end + 1
|
||
: seekNext(pos.end) + 1),
|
||
getMaskSet().validPositions[pos.begin] !== undefined &&
|
||
getMaskSet().validPositions[pos.begin].input ===
|
||
opts.groupSeparator &&
|
||
pos.end++),
|
||
stripValidPositions(pos.begin, pos.end, !1, strict),
|
||
!0 !== strict &&
|
||
(function () {
|
||
if (opts.keepStatic) {
|
||
for (
|
||
var validInputs = [],
|
||
lastAlt = getLastValidPosition(-1, !0),
|
||
positionsClone = $.extend(
|
||
!0,
|
||
{},
|
||
getMaskSet().validPositions
|
||
),
|
||
prevAltPos = getMaskSet().validPositions[lastAlt];
|
||
lastAlt >= 0;
|
||
lastAlt--
|
||
) {
|
||
var altPos = getMaskSet().validPositions[lastAlt];
|
||
if (altPos) {
|
||
if (
|
||
(!0 !== altPos.generatedInput &&
|
||
/[0-9a-bA-Z]/.test(altPos.input) &&
|
||
validInputs.push(altPos.input),
|
||
delete getMaskSet().validPositions[lastAlt],
|
||
altPos.alternation !== undefined &&
|
||
altPos.locator[altPos.alternation] !==
|
||
prevAltPos.locator[altPos.alternation])
|
||
)
|
||
break;
|
||
prevAltPos = altPos;
|
||
}
|
||
}
|
||
if (lastAlt > -1)
|
||
for (
|
||
getMaskSet().p = seekNext(getLastValidPosition(-1, !0));
|
||
validInputs.length > 0;
|
||
|
||
) {
|
||
var keypress = new $.Event("keypress");
|
||
(keypress.which = validInputs.pop().charCodeAt(0)),
|
||
EventHandlers.keypressEvent.call(
|
||
input,
|
||
keypress,
|
||
!0,
|
||
!1,
|
||
!1,
|
||
getMaskSet().p
|
||
);
|
||
}
|
||
else
|
||
getMaskSet().validPositions = $.extend(!0, {}, positionsClone);
|
||
}
|
||
})();
|
||
var lvp = getLastValidPosition(pos.begin, !0);
|
||
if (lvp < pos.begin) getMaskSet().p = seekNext(lvp);
|
||
else if (
|
||
!0 !== strict &&
|
||
((getMaskSet().p = pos.begin), !0 !== fromIsValid)
|
||
)
|
||
for (
|
||
;
|
||
getMaskSet().p < lvp &&
|
||
getMaskSet().validPositions[getMaskSet().p] === undefined;
|
||
|
||
)
|
||
getMaskSet().p++;
|
||
}
|
||
function initializeColorMask(input) {
|
||
function findCaretPos(clientx) {
|
||
var caretPos,
|
||
e = document.createElement("span");
|
||
for (var style in computedStyle)
|
||
isNaN(style) &&
|
||
-1 !== style.indexOf("font") &&
|
||
(e.style[style] = computedStyle[style]);
|
||
(e.style.textTransform = computedStyle.textTransform),
|
||
(e.style.letterSpacing = computedStyle.letterSpacing),
|
||
(e.style.position = "absolute"),
|
||
(e.style.height = "auto"),
|
||
(e.style.width = "auto"),
|
||
(e.style.visibility = "hidden"),
|
||
(e.style.whiteSpace = "nowrap"),
|
||
document.body.appendChild(e);
|
||
var itl,
|
||
inputText = input.inputmask._valueGet(),
|
||
previousWidth = 0;
|
||
for (
|
||
caretPos = 0, itl = inputText.length;
|
||
caretPos <= itl;
|
||
caretPos++
|
||
) {
|
||
if (
|
||
((e.innerHTML += inputText.charAt(caretPos) || "_"),
|
||
e.offsetWidth >= clientx)
|
||
) {
|
||
var offset1 = clientx - previousWidth,
|
||
offset2 = e.offsetWidth - clientx;
|
||
(e.innerHTML = inputText.charAt(caretPos)),
|
||
(caretPos =
|
||
(offset1 -= e.offsetWidth / 3) < offset2
|
||
? caretPos - 1
|
||
: caretPos);
|
||
break;
|
||
}
|
||
previousWidth = e.offsetWidth;
|
||
}
|
||
return document.body.removeChild(e), caretPos;
|
||
}
|
||
var computedStyle = (
|
||
input.ownerDocument.defaultView || window
|
||
).getComputedStyle(input, null),
|
||
template = document.createElement("div");
|
||
(template.style.width = computedStyle.width),
|
||
(template.style.textAlign = computedStyle.textAlign),
|
||
((colorMask = document.createElement("div")).className =
|
||
"im-colormask"),
|
||
input.parentNode.insertBefore(colorMask, input),
|
||
input.parentNode.removeChild(input),
|
||
colorMask.appendChild(template),
|
||
colorMask.appendChild(input),
|
||
(input.style.left = template.offsetLeft + "px"),
|
||
$(input).on("click", function (e) {
|
||
return (
|
||
caret(input, findCaretPos(e.clientX)),
|
||
EventHandlers.clickEvent.call(input, [e])
|
||
);
|
||
}),
|
||
$(input).on("keydown", function (e) {
|
||
e.shiftKey ||
|
||
!1 === opts.insertMode ||
|
||
setTimeout(function () {
|
||
renderColorMask(input);
|
||
}, 0);
|
||
});
|
||
}
|
||
function renderColorMask(input, caretPos, clear) {
|
||
function handleStatic() {
|
||
isStatic || (null !== test.fn && testPos.input !== undefined)
|
||
? isStatic &&
|
||
((null !== test.fn && testPos.input !== undefined) ||
|
||
"" === test.def) &&
|
||
((isStatic = !1), (maskTemplate += "</span>"))
|
||
: ((isStatic = !0), (maskTemplate += "<span class='im-static'>"));
|
||
}
|
||
function handleCaret(force) {
|
||
(!0 !== force && pos !== caretPos.begin) ||
|
||
document.activeElement !== input ||
|
||
(maskTemplate +=
|
||
"<span class='im-caret' style='border-right-width: 1px;border-right-style: solid;'></span>");
|
||
}
|
||
var test,
|
||
testPos,
|
||
ndxIntlzr,
|
||
maskTemplate = "",
|
||
isStatic = !1,
|
||
pos = 0;
|
||
if (colorMask !== undefined) {
|
||
var buffer = getBuffer();
|
||
if (
|
||
(caretPos === undefined
|
||
? (caretPos = caret(input))
|
||
: caretPos.begin === undefined &&
|
||
(caretPos = {
|
||
begin: caretPos,
|
||
end: caretPos,
|
||
}),
|
||
!0 !== clear)
|
||
) {
|
||
var lvp = getLastValidPosition();
|
||
do {
|
||
handleCaret(),
|
||
getMaskSet().validPositions[pos]
|
||
? ((testPos = getMaskSet().validPositions[pos]),
|
||
(test = testPos.match),
|
||
(ndxIntlzr = testPos.locator.slice()),
|
||
handleStatic(),
|
||
(maskTemplate += buffer[pos]))
|
||
: ((testPos = getTestTemplate(pos, ndxIntlzr, pos - 1)),
|
||
(test = testPos.match),
|
||
(ndxIntlzr = testPos.locator.slice()),
|
||
(!1 === opts.jitMasking ||
|
||
pos < lvp ||
|
||
("number" == typeof opts.jitMasking &&
|
||
isFinite(opts.jitMasking) &&
|
||
opts.jitMasking > pos)) &&
|
||
(handleStatic(),
|
||
(maskTemplate += getPlaceholder(pos, test)))),
|
||
pos++;
|
||
} while (
|
||
((maxLength === undefined || pos < maxLength) &&
|
||
(null !== test.fn || "" !== test.def)) ||
|
||
lvp > pos ||
|
||
isStatic
|
||
);
|
||
-1 === maskTemplate.indexOf("im-caret") && handleCaret(!0),
|
||
isStatic && handleStatic();
|
||
}
|
||
var template = colorMask.getElementsByTagName("div")[0];
|
||
(template.innerHTML = maskTemplate),
|
||
input.inputmask.positionColorMask(input, template);
|
||
}
|
||
}
|
||
(maskset = maskset || this.maskset), (opts = opts || this.opts);
|
||
var undoValue,
|
||
$el,
|
||
maxLength,
|
||
colorMask,
|
||
inputmask = this,
|
||
el = this.el,
|
||
isRTL = this.isRTL,
|
||
skipKeyPressEvent = !1,
|
||
skipInputEvent = !1,
|
||
ignorable = !1,
|
||
mouseEnter = !1,
|
||
EventRuler = {
|
||
on: function (input, eventName, eventHandler) {
|
||
var ev = function (e) {
|
||
if (this.inputmask === undefined && "FORM" !== this.nodeName) {
|
||
var imOpts = $.data(this, "_inputmask_opts");
|
||
imOpts ? new Inputmask(imOpts).mask(this) : EventRuler.off(this);
|
||
} else {
|
||
if (
|
||
"setvalue" === e.type ||
|
||
"FORM" === this.nodeName ||
|
||
!(
|
||
this.disabled ||
|
||
(this.readOnly &&
|
||
!(
|
||
("keydown" === e.type && e.ctrlKey && 67 === e.keyCode) ||
|
||
(!1 === opts.tabThrough &&
|
||
e.keyCode === Inputmask.keyCode.TAB)
|
||
))
|
||
)
|
||
) {
|
||
switch (e.type) {
|
||
case "input":
|
||
if (!0 === skipInputEvent)
|
||
return (skipInputEvent = !1), e.preventDefault();
|
||
break;
|
||
|
||
case "keydown":
|
||
(skipKeyPressEvent = !1), (skipInputEvent = !1);
|
||
break;
|
||
|
||
case "keypress":
|
||
if (!0 === skipKeyPressEvent) return e.preventDefault();
|
||
skipKeyPressEvent = !0;
|
||
break;
|
||
|
||
case "click":
|
||
if (iemobile || iphone) {
|
||
var that = this,
|
||
args = arguments;
|
||
return (
|
||
setTimeout(function () {
|
||
eventHandler.apply(that, args);
|
||
}, 0),
|
||
!1
|
||
);
|
||
}
|
||
}
|
||
var returnVal = eventHandler.apply(this, arguments);
|
||
return (
|
||
!1 === returnVal && (e.preventDefault(), e.stopPropagation()),
|
||
returnVal
|
||
);
|
||
}
|
||
e.preventDefault();
|
||
}
|
||
};
|
||
(input.inputmask.events[eventName] =
|
||
input.inputmask.events[eventName] || []),
|
||
input.inputmask.events[eventName].push(ev),
|
||
-1 !== $.inArray(eventName, ["submit", "reset"])
|
||
? null !== input.form && $(input.form).on(eventName, ev)
|
||
: $(input).on(eventName, ev);
|
||
},
|
||
off: function (input, event) {
|
||
if (input.inputmask && input.inputmask.events) {
|
||
var events;
|
||
event
|
||
? ((events = [])[event] = input.inputmask.events[event])
|
||
: (events = input.inputmask.events),
|
||
$.each(events, function (eventName, evArr) {
|
||
for (; evArr.length > 0; ) {
|
||
var ev = evArr.pop();
|
||
-1 !== $.inArray(eventName, ["submit", "reset"])
|
||
? null !== input.form && $(input.form).off(eventName, ev)
|
||
: $(input).off(eventName, ev);
|
||
}
|
||
delete input.inputmask.events[eventName];
|
||
});
|
||
}
|
||
},
|
||
},
|
||
EventHandlers = {
|
||
keydownEvent: function (e) {
|
||
var input = this,
|
||
$input = $(input),
|
||
k = e.keyCode,
|
||
pos = caret(input);
|
||
if (
|
||
k === Inputmask.keyCode.BACKSPACE ||
|
||
k === Inputmask.keyCode.DELETE ||
|
||
(iphone && k === Inputmask.keyCode.BACKSPACE_SAFARI) ||
|
||
(e.ctrlKey &&
|
||
k === Inputmask.keyCode.X &&
|
||
!(function (eventName) {
|
||
var el = document.createElement("input"),
|
||
evName = "on" + eventName,
|
||
isSupported = evName in el;
|
||
return (
|
||
isSupported ||
|
||
(el.setAttribute(evName, "return;"),
|
||
(isSupported = "function" == typeof el[evName])),
|
||
(el = null),
|
||
isSupported
|
||
);
|
||
})("cut"))
|
||
)
|
||
e.preventDefault(),
|
||
handleRemove(input, k, pos),
|
||
writeBuffer(
|
||
input,
|
||
getBuffer(!0),
|
||
getMaskSet().p,
|
||
e,
|
||
input.inputmask._valueGet() !== getBuffer().join("")
|
||
),
|
||
input.inputmask._valueGet() === getBufferTemplate().join("")
|
||
? $input.trigger("cleared")
|
||
: !0 === isComplete(getBuffer()) && $input.trigger("complete");
|
||
else if (
|
||
k === Inputmask.keyCode.END ||
|
||
k === Inputmask.keyCode.PAGE_DOWN
|
||
) {
|
||
e.preventDefault();
|
||
var caretPos = seekNext(getLastValidPosition());
|
||
opts.insertMode ||
|
||
caretPos !== getMaskSet().maskLength ||
|
||
e.shiftKey ||
|
||
caretPos--,
|
||
caret(input, e.shiftKey ? pos.begin : caretPos, caretPos, !0);
|
||
} else
|
||
(k === Inputmask.keyCode.HOME && !e.shiftKey) ||
|
||
k === Inputmask.keyCode.PAGE_UP
|
||
? (e.preventDefault(),
|
||
caret(input, 0, e.shiftKey ? pos.begin : 0, !0))
|
||
: ((opts.undoOnEscape && k === Inputmask.keyCode.ESCAPE) ||
|
||
(90 === k && e.ctrlKey)) &&
|
||
!0 !== e.altKey
|
||
? (checkVal(input, !0, !1, undoValue.split("")),
|
||
$input.trigger("click"))
|
||
: k !== Inputmask.keyCode.INSERT || e.shiftKey || e.ctrlKey
|
||
? !0 === opts.tabThrough && k === Inputmask.keyCode.TAB
|
||
? (!0 === e.shiftKey
|
||
? (null === getTest(pos.begin).match.fn &&
|
||
(pos.begin = seekNext(pos.begin)),
|
||
(pos.end = seekPrevious(pos.begin, !0)),
|
||
(pos.begin = seekPrevious(pos.end, !0)))
|
||
: ((pos.begin = seekNext(pos.begin, !0)),
|
||
(pos.end = seekNext(pos.begin, !0)),
|
||
pos.end < getMaskSet().maskLength && pos.end--),
|
||
pos.begin < getMaskSet().maskLength &&
|
||
(e.preventDefault(), caret(input, pos.begin, pos.end)))
|
||
: e.shiftKey ||
|
||
(!1 === opts.insertMode &&
|
||
(k === Inputmask.keyCode.RIGHT
|
||
? setTimeout(function () {
|
||
var caretPos = caret(input);
|
||
caret(input, caretPos.begin);
|
||
}, 0)
|
||
: k === Inputmask.keyCode.LEFT &&
|
||
setTimeout(function () {
|
||
var caretPos = caret(input);
|
||
caret(
|
||
input,
|
||
isRTL ? caretPos.begin + 1 : caretPos.begin - 1
|
||
);
|
||
}, 0)))
|
||
: ((opts.insertMode = !opts.insertMode),
|
||
caret(
|
||
input,
|
||
opts.insertMode || pos.begin !== getMaskSet().maskLength
|
||
? pos.begin
|
||
: pos.begin - 1
|
||
));
|
||
opts.onKeyDown.call(this, e, getBuffer(), caret(input).begin, opts),
|
||
(ignorable = -1 !== $.inArray(k, opts.ignorables));
|
||
},
|
||
keypressEvent: function (e, checkval, writeOut, strict, ndx) {
|
||
var input = this,
|
||
$input = $(input),
|
||
k = e.which || e.charCode || e.keyCode;
|
||
if (
|
||
!(!0 === checkval || (e.ctrlKey && e.altKey)) &&
|
||
(e.ctrlKey || e.metaKey || ignorable)
|
||
)
|
||
return (
|
||
k === Inputmask.keyCode.ENTER &&
|
||
undoValue !== getBuffer().join("") &&
|
||
((undoValue = getBuffer().join("")),
|
||
setTimeout(function () {
|
||
$input.trigger("change");
|
||
}, 0)),
|
||
!0
|
||
);
|
||
if (k) {
|
||
46 === k &&
|
||
!1 === e.shiftKey &&
|
||
"" !== opts.radixPoint &&
|
||
(k = opts.radixPoint.charCodeAt(0));
|
||
var forwardPosition,
|
||
pos = checkval
|
||
? {
|
||
begin: ndx,
|
||
end: ndx,
|
||
}
|
||
: caret(input),
|
||
c = String.fromCharCode(k);
|
||
getMaskSet().writeOutBuffer = !0;
|
||
var valResult = isValid(pos, c, strict);
|
||
if (
|
||
(!1 !== valResult &&
|
||
(resetMaskSet(!0),
|
||
(forwardPosition =
|
||
valResult.caret !== undefined
|
||
? valResult.caret
|
||
: checkval
|
||
? valResult.pos + 1
|
||
: seekNext(valResult.pos)),
|
||
(getMaskSet().p = forwardPosition)),
|
||
!1 !== writeOut &&
|
||
(setTimeout(function () {
|
||
opts.onKeyValidation.call(input, k, valResult, opts);
|
||
}, 0),
|
||
getMaskSet().writeOutBuffer && !1 !== valResult))
|
||
) {
|
||
var buffer = getBuffer();
|
||
writeBuffer(
|
||
input,
|
||
buffer,
|
||
opts.numericInput && valResult.caret === undefined
|
||
? seekPrevious(forwardPosition)
|
||
: forwardPosition,
|
||
e,
|
||
!0 !== checkval
|
||
),
|
||
!0 !== checkval &&
|
||
setTimeout(function () {
|
||
!0 === isComplete(buffer) && $input.trigger("complete");
|
||
}, 0);
|
||
}
|
||
if ((e.preventDefault(), checkval))
|
||
return (
|
||
!1 !== valResult &&
|
||
(valResult.forwardPosition = forwardPosition),
|
||
valResult
|
||
);
|
||
}
|
||
},
|
||
pasteEvent: function (e) {
|
||
var tempValue,
|
||
input = this,
|
||
ev = e.originalEvent || e,
|
||
$input = $(input),
|
||
inputValue = input.inputmask._valueGet(!0),
|
||
caretPos = caret(input);
|
||
isRTL &&
|
||
((tempValue = caretPos.end),
|
||
(caretPos.end = caretPos.begin),
|
||
(caretPos.begin = tempValue));
|
||
var valueBeforeCaret = inputValue.substr(0, caretPos.begin),
|
||
valueAfterCaret = inputValue.substr(
|
||
caretPos.end,
|
||
inputValue.length
|
||
);
|
||
if (
|
||
(valueBeforeCaret ===
|
||
(isRTL ? getBufferTemplate().reverse() : getBufferTemplate())
|
||
.slice(0, caretPos.begin)
|
||
.join("") && (valueBeforeCaret = ""),
|
||
valueAfterCaret ===
|
||
(isRTL ? getBufferTemplate().reverse() : getBufferTemplate())
|
||
.slice(caretPos.end)
|
||
.join("") && (valueAfterCaret = ""),
|
||
isRTL &&
|
||
((tempValue = valueBeforeCaret),
|
||
(valueBeforeCaret = valueAfterCaret),
|
||
(valueAfterCaret = tempValue)),
|
||
window.clipboardData && window.clipboardData.getData)
|
||
)
|
||
inputValue =
|
||
valueBeforeCaret +
|
||
window.clipboardData.getData("Text") +
|
||
valueAfterCaret;
|
||
else {
|
||
if (!ev.clipboardData || !ev.clipboardData.getData) return !0;
|
||
inputValue =
|
||
valueBeforeCaret +
|
||
ev.clipboardData.getData("text/plain") +
|
||
valueAfterCaret;
|
||
}
|
||
var pasteValue = inputValue;
|
||
if ($.isFunction(opts.onBeforePaste)) {
|
||
if (
|
||
!1 ===
|
||
(pasteValue = opts.onBeforePaste.call(
|
||
inputmask,
|
||
inputValue,
|
||
opts
|
||
))
|
||
)
|
||
return e.preventDefault();
|
||
pasteValue || (pasteValue = inputValue);
|
||
}
|
||
return (
|
||
checkVal(
|
||
input,
|
||
!1,
|
||
!1,
|
||
isRTL
|
||
? pasteValue.split("").reverse()
|
||
: pasteValue.toString().split("")
|
||
),
|
||
writeBuffer(
|
||
input,
|
||
getBuffer(),
|
||
seekNext(getLastValidPosition()),
|
||
e,
|
||
undoValue !== getBuffer().join("")
|
||
),
|
||
!0 === isComplete(getBuffer()) && $input.trigger("complete"),
|
||
e.preventDefault()
|
||
);
|
||
},
|
||
inputFallBackEvent: function (e) {
|
||
var input = this,
|
||
inputValue = input.inputmask._valueGet();
|
||
if (getBuffer().join("") !== inputValue) {
|
||
var caretPos = caret(input);
|
||
if (
|
||
!1 ===
|
||
(function (input, inputValue, caretPos) {
|
||
if (
|
||
("." === inputValue.charAt(caretPos.begin - 1) &&
|
||
"" !== opts.radixPoint &&
|
||
(((inputValue = inputValue.split(""))[caretPos.begin - 1] =
|
||
opts.radixPoint.charAt(0)),
|
||
(inputValue = inputValue.join(""))),
|
||
inputValue.charAt(caretPos.begin - 1) === opts.radixPoint &&
|
||
inputValue.length > getBuffer().length)
|
||
) {
|
||
var keypress = new $.Event("keypress");
|
||
return (
|
||
(keypress.which = opts.radixPoint.charCodeAt(0)),
|
||
EventHandlers.keypressEvent.call(
|
||
input,
|
||
keypress,
|
||
!0,
|
||
!0,
|
||
!1,
|
||
caretPos.begin - 1
|
||
),
|
||
!1
|
||
);
|
||
}
|
||
})(input, inputValue, caretPos)
|
||
)
|
||
return !1;
|
||
if (
|
||
((inputValue = inputValue.replace(
|
||
new RegExp(
|
||
"(" +
|
||
Inputmask.escapeRegex(getBufferTemplate().join("")) +
|
||
")*"
|
||
),
|
||
""
|
||
)),
|
||
!1 ===
|
||
(function (input, inputValue, caretPos) {
|
||
if (iemobile) {
|
||
var inputChar = inputValue.replace(
|
||
getBuffer().join(""),
|
||
""
|
||
);
|
||
if (1 === inputChar.length) {
|
||
var keypress = new $.Event("keypress");
|
||
return (
|
||
(keypress.which = inputChar.charCodeAt(0)),
|
||
EventHandlers.keypressEvent.call(
|
||
input,
|
||
keypress,
|
||
!0,
|
||
!0,
|
||
!1,
|
||
getMaskSet().validPositions[caretPos.begin - 1]
|
||
? caretPos.begin
|
||
: caretPos.begin - 1
|
||
),
|
||
!1
|
||
);
|
||
}
|
||
}
|
||
})(input, inputValue, caretPos))
|
||
)
|
||
return !1;
|
||
caretPos.begin > inputValue.length &&
|
||
(caret(input, inputValue.length), (caretPos = caret(input)));
|
||
var buffer = getBuffer().join(""),
|
||
frontPart = inputValue.substr(0, caretPos.begin),
|
||
backPart = inputValue.substr(caretPos.begin),
|
||
frontBufferPart = buffer.substr(0, caretPos.begin),
|
||
backBufferPart = buffer.substr(caretPos.begin),
|
||
selection = caretPos,
|
||
entries = "",
|
||
isEntry = !1;
|
||
if (frontPart !== frontBufferPart) {
|
||
selection.begin = 0;
|
||
for (
|
||
var fpl = (isEntry = frontPart.length >= frontBufferPart.length)
|
||
? frontPart.length
|
||
: frontBufferPart.length,
|
||
i = 0;
|
||
frontPart.charAt(i) === frontBufferPart.charAt(i) && i < fpl;
|
||
i++
|
||
)
|
||
selection.begin++;
|
||
isEntry &&
|
||
(entries += frontPart.slice(selection.begin, selection.end));
|
||
}
|
||
backPart !== backBufferPart &&
|
||
(backPart.length > backBufferPart.length
|
||
? isEntry && (selection.end = selection.begin)
|
||
: backPart.length < backBufferPart.length
|
||
? (selection.end += backBufferPart.length - backPart.length)
|
||
: backPart.charAt(0) !== backBufferPart.charAt(0) &&
|
||
selection.end++),
|
||
writeBuffer(input, getBuffer(), selection),
|
||
entries.length > 0
|
||
? $.each(entries.split(""), function (ndx, entry) {
|
||
var keypress = new $.Event("keypress");
|
||
(keypress.which = entry.charCodeAt(0)),
|
||
(ignorable = !1),
|
||
EventHandlers.keypressEvent.call(input, keypress);
|
||
})
|
||
: (selection.begin === selection.end - 1 &&
|
||
caret(
|
||
input,
|
||
seekPrevious(selection.begin + 1),
|
||
selection.end
|
||
),
|
||
(e.keyCode = Inputmask.keyCode.DELETE),
|
||
EventHandlers.keydownEvent.call(input, e)),
|
||
e.preventDefault();
|
||
}
|
||
},
|
||
setValueEvent: function (e) {
|
||
this.inputmask.refreshValue = !1;
|
||
var input = this,
|
||
value = input.inputmask._valueGet(!0);
|
||
$.isFunction(opts.onBeforeMask) &&
|
||
(value = opts.onBeforeMask.call(inputmask, value, opts) || value),
|
||
(value = value.split("")),
|
||
checkVal(input, !0, !1, isRTL ? value.reverse() : value),
|
||
(undoValue = getBuffer().join("")),
|
||
(opts.clearMaskOnLostFocus || opts.clearIncomplete) &&
|
||
input.inputmask._valueGet() === getBufferTemplate().join("") &&
|
||
input.inputmask._valueSet("");
|
||
},
|
||
focusEvent: function (e) {
|
||
var input = this,
|
||
nptValue = input.inputmask._valueGet();
|
||
opts.showMaskOnFocus &&
|
||
(!opts.showMaskOnHover ||
|
||
(opts.showMaskOnHover && "" === nptValue)) &&
|
||
(input.inputmask._valueGet() !== getBuffer().join("")
|
||
? writeBuffer(
|
||
input,
|
||
getBuffer(),
|
||
seekNext(getLastValidPosition())
|
||
)
|
||
: !1 === mouseEnter &&
|
||
caret(input, seekNext(getLastValidPosition()))),
|
||
!0 === opts.positionCaretOnTab &&
|
||
!1 === mouseEnter &&
|
||
"" !== nptValue &&
|
||
(writeBuffer(input, getBuffer(), caret(input)),
|
||
EventHandlers.clickEvent.apply(input, [e, !0])),
|
||
(undoValue = getBuffer().join(""));
|
||
},
|
||
mouseleaveEvent: function (e) {
|
||
var input = this;
|
||
if (
|
||
((mouseEnter = !1),
|
||
opts.clearMaskOnLostFocus && document.activeElement !== input)
|
||
) {
|
||
var buffer = getBuffer().slice(),
|
||
nptValue = input.inputmask._valueGet();
|
||
nptValue !== input.getAttribute("placeholder") &&
|
||
"" !== nptValue &&
|
||
(-1 === getLastValidPosition() &&
|
||
nptValue === getBufferTemplate().join("")
|
||
? (buffer = [])
|
||
: clearOptionalTail(buffer),
|
||
writeBuffer(input, buffer));
|
||
}
|
||
},
|
||
clickEvent: function (e, tabbed) {
|
||
function doRadixFocus(clickPos) {
|
||
if ("" !== opts.radixPoint) {
|
||
var vps = getMaskSet().validPositions;
|
||
if (
|
||
vps[clickPos] === undefined ||
|
||
vps[clickPos].input === getPlaceholder(clickPos)
|
||
) {
|
||
if (clickPos < seekNext(-1)) return !0;
|
||
var radixPos = $.inArray(opts.radixPoint, getBuffer());
|
||
if (-1 !== radixPos) {
|
||
for (var vp in vps)
|
||
if (radixPos < vp && vps[vp].input !== getPlaceholder(vp))
|
||
return !1;
|
||
return !0;
|
||
}
|
||
}
|
||
}
|
||
return !1;
|
||
}
|
||
var input = this;
|
||
setTimeout(function () {
|
||
if (document.activeElement === input) {
|
||
var selectedCaret = caret(input);
|
||
if (
|
||
(tabbed &&
|
||
(isRTL
|
||
? (selectedCaret.end = selectedCaret.begin)
|
||
: (selectedCaret.begin = selectedCaret.end)),
|
||
selectedCaret.begin === selectedCaret.end)
|
||
)
|
||
switch (opts.positionCaretOnClick) {
|
||
case "none":
|
||
break;
|
||
|
||
case "radixFocus":
|
||
if (doRadixFocus(selectedCaret.begin)) {
|
||
var radixPos = getBuffer()
|
||
.join("")
|
||
.indexOf(opts.radixPoint);
|
||
caret(
|
||
input,
|
||
opts.numericInput ? seekNext(radixPos) : radixPos
|
||
);
|
||
break;
|
||
}
|
||
|
||
default:
|
||
var clickPosition = selectedCaret.begin,
|
||
lvclickPosition = getLastValidPosition(clickPosition, !0),
|
||
lastPosition = seekNext(lvclickPosition);
|
||
if (clickPosition < lastPosition)
|
||
caret(
|
||
input,
|
||
isMask(clickPosition, !0) ||
|
||
isMask(clickPosition - 1, !0)
|
||
? clickPosition
|
||
: seekNext(clickPosition)
|
||
);
|
||
else {
|
||
var lvp = getMaskSet().validPositions[lvclickPosition],
|
||
tt = getTestTemplate(
|
||
lastPosition,
|
||
lvp ? lvp.match.locator : undefined,
|
||
lvp
|
||
),
|
||
placeholder = getPlaceholder(lastPosition, tt.match);
|
||
if (
|
||
("" !== placeholder &&
|
||
getBuffer()[lastPosition] !== placeholder &&
|
||
!0 !== tt.match.optionalQuantifier &&
|
||
!0 !== tt.match.newBlockMarker) ||
|
||
(!isMask(lastPosition, !0) &&
|
||
tt.match.def === placeholder)
|
||
) {
|
||
var newPos = seekNext(lastPosition);
|
||
(clickPosition >= newPos ||
|
||
clickPosition === lastPosition) &&
|
||
(lastPosition = newPos);
|
||
}
|
||
caret(input, lastPosition);
|
||
}
|
||
}
|
||
}
|
||
}, 0);
|
||
},
|
||
dblclickEvent: function (e) {
|
||
var input = this;
|
||
setTimeout(function () {
|
||
caret(input, 0, seekNext(getLastValidPosition()));
|
||
}, 0);
|
||
},
|
||
cutEvent: function (e) {
|
||
var input = this,
|
||
$input = $(input),
|
||
pos = caret(input),
|
||
ev = e.originalEvent || e,
|
||
clipboardData = window.clipboardData || ev.clipboardData,
|
||
clipData = isRTL
|
||
? getBuffer().slice(pos.end, pos.begin)
|
||
: getBuffer().slice(pos.begin, pos.end);
|
||
clipboardData.setData(
|
||
"text",
|
||
isRTL ? clipData.reverse().join("") : clipData.join("")
|
||
),
|
||
document.execCommand && document.execCommand("copy"),
|
||
handleRemove(input, Inputmask.keyCode.DELETE, pos),
|
||
writeBuffer(
|
||
input,
|
||
getBuffer(),
|
||
getMaskSet().p,
|
||
e,
|
||
undoValue !== getBuffer().join("")
|
||
),
|
||
input.inputmask._valueGet() === getBufferTemplate().join("") &&
|
||
$input.trigger("cleared");
|
||
},
|
||
blurEvent: function (e) {
|
||
var $input = $(this),
|
||
input = this;
|
||
if (input.inputmask) {
|
||
var nptValue = input.inputmask._valueGet(),
|
||
buffer = getBuffer().slice();
|
||
"" !== nptValue &&
|
||
(opts.clearMaskOnLostFocus &&
|
||
(-1 === getLastValidPosition() &&
|
||
nptValue === getBufferTemplate().join("")
|
||
? (buffer = [])
|
||
: clearOptionalTail(buffer)),
|
||
!1 === isComplete(buffer) &&
|
||
(setTimeout(function () {
|
||
$input.trigger("incomplete");
|
||
}, 0),
|
||
opts.clearIncomplete &&
|
||
(resetMaskSet(),
|
||
(buffer = opts.clearMaskOnLostFocus
|
||
? []
|
||
: getBufferTemplate().slice()))),
|
||
writeBuffer(input, buffer, undefined, e)),
|
||
undoValue !== getBuffer().join("") &&
|
||
((undoValue = buffer.join("")), $input.trigger("change"));
|
||
}
|
||
},
|
||
mouseenterEvent: function (e) {
|
||
var input = this;
|
||
(mouseEnter = !0),
|
||
document.activeElement !== input &&
|
||
opts.showMaskOnHover &&
|
||
input.inputmask._valueGet() !== getBuffer().join("") &&
|
||
writeBuffer(input, getBuffer());
|
||
},
|
||
submitEvent: function (e) {
|
||
undoValue !== getBuffer().join("") && $el.trigger("change"),
|
||
opts.clearMaskOnLostFocus &&
|
||
-1 === getLastValidPosition() &&
|
||
el.inputmask._valueGet &&
|
||
el.inputmask._valueGet() === getBufferTemplate().join("") &&
|
||
el.inputmask._valueSet(""),
|
||
opts.removeMaskOnSubmit &&
|
||
(el.inputmask._valueSet(el.inputmask.unmaskedvalue(), !0),
|
||
setTimeout(function () {
|
||
writeBuffer(el, getBuffer());
|
||
}, 0));
|
||
},
|
||
resetEvent: function (e) {
|
||
(el.inputmask.refreshValue = !0),
|
||
setTimeout(function () {
|
||
$el.trigger("setvalue");
|
||
}, 0);
|
||
},
|
||
};
|
||
Inputmask.prototype.positionColorMask = function (input, template) {
|
||
input.style.left = template.offsetLeft + "px";
|
||
};
|
||
var valueBuffer;
|
||
if (actionObj !== undefined)
|
||
switch (actionObj.action) {
|
||
case "isComplete":
|
||
return (el = actionObj.el), isComplete(getBuffer());
|
||
|
||
case "unmaskedvalue":
|
||
return (
|
||
(el !== undefined && actionObj.value === undefined) ||
|
||
((valueBuffer = actionObj.value),
|
||
(valueBuffer = (
|
||
$.isFunction(opts.onBeforeMask)
|
||
? opts.onBeforeMask.call(inputmask, valueBuffer, opts) ||
|
||
valueBuffer
|
||
: valueBuffer
|
||
).split("")),
|
||
checkVal(
|
||
undefined,
|
||
!1,
|
||
!1,
|
||
isRTL ? valueBuffer.reverse() : valueBuffer
|
||
),
|
||
$.isFunction(opts.onBeforeWrite) &&
|
||
opts.onBeforeWrite.call(
|
||
inputmask,
|
||
undefined,
|
||
getBuffer(),
|
||
0,
|
||
opts
|
||
)),
|
||
unmaskedvalue(el)
|
||
);
|
||
|
||
case "mask":
|
||
!(function (elem) {
|
||
EventRuler.off(elem);
|
||
var isSupported = (function (input, opts) {
|
||
var elementType = input.getAttribute("type"),
|
||
isSupported =
|
||
("INPUT" === input.tagName &&
|
||
-1 !== $.inArray(elementType, opts.supportsInputType)) ||
|
||
input.isContentEditable ||
|
||
"TEXTAREA" === input.tagName;
|
||
if (!isSupported)
|
||
if ("INPUT" === input.tagName) {
|
||
var el = document.createElement("input");
|
||
el.setAttribute("type", elementType),
|
||
(isSupported = "text" === el.type),
|
||
(el = null);
|
||
} else isSupported = "partial";
|
||
return (
|
||
!1 !== isSupported
|
||
? (function (npt) {
|
||
function getter() {
|
||
return this.inputmask
|
||
? this.inputmask.opts.autoUnmask
|
||
? this.inputmask.unmaskedvalue()
|
||
: -1 !== getLastValidPosition() ||
|
||
!0 !== opts.nullable
|
||
? document.activeElement === this &&
|
||
opts.clearMaskOnLostFocus
|
||
? (isRTL
|
||
? clearOptionalTail(
|
||
getBuffer().slice()
|
||
).reverse()
|
||
: clearOptionalTail(getBuffer().slice())
|
||
).join("")
|
||
: valueGet.call(this)
|
||
: ""
|
||
: valueGet.call(this);
|
||
}
|
||
function setter(value) {
|
||
valueSet.call(this, value),
|
||
this.inputmask && $(this).trigger("setvalue");
|
||
}
|
||
var valueGet, valueSet;
|
||
if (!npt.inputmask.__valueGet) {
|
||
if (!0 !== opts.noValuePatching) {
|
||
if (Object.getOwnPropertyDescriptor) {
|
||
"function" != typeof Object.getPrototypeOf &&
|
||
(Object.getPrototypeOf =
|
||
"object" == typeof "test".__proto__
|
||
? function (object) {
|
||
return object.__proto__;
|
||
}
|
||
: function (object) {
|
||
return object.constructor.prototype;
|
||
});
|
||
var valueProperty = Object.getPrototypeOf
|
||
? Object.getOwnPropertyDescriptor(
|
||
Object.getPrototypeOf(npt),
|
||
"value"
|
||
)
|
||
: undefined;
|
||
valueProperty &&
|
||
valueProperty.get &&
|
||
valueProperty.set
|
||
? ((valueGet = valueProperty.get),
|
||
(valueSet = valueProperty.set),
|
||
Object.defineProperty(npt, "value", {
|
||
get: getter,
|
||
set: setter,
|
||
configurable: !0,
|
||
}))
|
||
: "INPUT" !== npt.tagName &&
|
||
((valueGet = function () {
|
||
return this.textContent;
|
||
}),
|
||
(valueSet = function (value) {
|
||
this.textContent = value;
|
||
}),
|
||
Object.defineProperty(npt, "value", {
|
||
get: getter,
|
||
set: setter,
|
||
configurable: !0,
|
||
}));
|
||
} else
|
||
document.__lookupGetter__ &&
|
||
npt.__lookupGetter__("value") &&
|
||
((valueGet = npt.__lookupGetter__("value")),
|
||
(valueSet = npt.__lookupSetter__("value")),
|
||
npt.__defineGetter__("value", getter),
|
||
npt.__defineSetter__("value", setter));
|
||
(npt.inputmask.__valueGet = valueGet),
|
||
(npt.inputmask.__valueSet = valueSet);
|
||
}
|
||
(npt.inputmask._valueGet = function (overruleRTL) {
|
||
return isRTL && !0 !== overruleRTL
|
||
? valueGet
|
||
.call(this.el)
|
||
.split("")
|
||
.reverse()
|
||
.join("")
|
||
: valueGet.call(this.el);
|
||
}),
|
||
(npt.inputmask._valueSet = function (
|
||
value,
|
||
overruleRTL
|
||
) {
|
||
valueSet.call(
|
||
this.el,
|
||
null === value || value === undefined
|
||
? ""
|
||
: !0 !== overruleRTL && isRTL
|
||
? value.split("").reverse().join("")
|
||
: value
|
||
);
|
||
}),
|
||
valueGet === undefined &&
|
||
((valueGet = function () {
|
||
return this.value;
|
||
}),
|
||
(valueSet = function (value) {
|
||
this.value = value;
|
||
}),
|
||
(function (type) {
|
||
if (
|
||
$.valHooks &&
|
||
($.valHooks[type] === undefined ||
|
||
!0 !== $.valHooks[type].inputmaskpatch)
|
||
) {
|
||
var valhookGet =
|
||
$.valHooks[type] && $.valHooks[type].get
|
||
? $.valHooks[type].get
|
||
: function (elem) {
|
||
return elem.value;
|
||
},
|
||
valhookSet =
|
||
$.valHooks[type] && $.valHooks[type].set
|
||
? $.valHooks[type].set
|
||
: function (elem, value) {
|
||
return (elem.value = value), elem;
|
||
};
|
||
$.valHooks[type] = {
|
||
get: function (elem) {
|
||
if (elem.inputmask) {
|
||
if (elem.inputmask.opts.autoUnmask)
|
||
return elem.inputmask.unmaskedvalue();
|
||
var result = valhookGet(elem);
|
||
return -1 !==
|
||
getLastValidPosition(
|
||
undefined,
|
||
undefined,
|
||
elem.inputmask.maskset.validPositions
|
||
) || !0 !== opts.nullable
|
||
? result
|
||
: "";
|
||
}
|
||
return valhookGet(elem);
|
||
},
|
||
set: function (elem, value) {
|
||
var result,
|
||
$elem = $(elem);
|
||
return (
|
||
(result = valhookSet(elem, value)),
|
||
elem.inputmask &&
|
||
$elem.trigger("setvalue"),
|
||
result
|
||
);
|
||
},
|
||
inputmaskpatch: !0,
|
||
};
|
||
}
|
||
})(npt.type),
|
||
(function (npt) {
|
||
EventRuler.on(
|
||
npt,
|
||
"mouseenter",
|
||
function (event) {
|
||
var $input = $(this);
|
||
this.inputmask._valueGet() !==
|
||
getBuffer().join("") &&
|
||
$input.trigger("setvalue");
|
||
}
|
||
);
|
||
})(npt));
|
||
}
|
||
})(input)
|
||
: (input.inputmask = undefined),
|
||
isSupported
|
||
);
|
||
})(elem, opts);
|
||
if (
|
||
!1 !== isSupported &&
|
||
((el = elem),
|
||
($el = $(el)),
|
||
-1 ===
|
||
(maxLength = el !== undefined ? el.maxLength : undefined) &&
|
||
(maxLength = undefined),
|
||
!0 === opts.colorMask && initializeColorMask(el),
|
||
android &&
|
||
(el.hasOwnProperty("inputmode") &&
|
||
((el.inputmode = opts.inputmode),
|
||
el.setAttribute("inputmode", opts.inputmode)),
|
||
"rtfm" === opts.androidHack &&
|
||
(!0 !== opts.colorMask && initializeColorMask(el),
|
||
(el.type = "password"))),
|
||
!0 === isSupported &&
|
||
(EventRuler.on(el, "submit", EventHandlers.submitEvent),
|
||
EventRuler.on(el, "reset", EventHandlers.resetEvent),
|
||
EventRuler.on(el, "mouseenter", EventHandlers.mouseenterEvent),
|
||
EventRuler.on(el, "blur", EventHandlers.blurEvent),
|
||
EventRuler.on(el, "focus", EventHandlers.focusEvent),
|
||
EventRuler.on(el, "mouseleave", EventHandlers.mouseleaveEvent),
|
||
!0 !== opts.colorMask &&
|
||
EventRuler.on(el, "click", EventHandlers.clickEvent),
|
||
EventRuler.on(el, "dblclick", EventHandlers.dblclickEvent),
|
||
EventRuler.on(el, "paste", EventHandlers.pasteEvent),
|
||
EventRuler.on(el, "dragdrop", EventHandlers.pasteEvent),
|
||
EventRuler.on(el, "drop", EventHandlers.pasteEvent),
|
||
EventRuler.on(el, "cut", EventHandlers.cutEvent),
|
||
EventRuler.on(el, "complete", opts.oncomplete),
|
||
EventRuler.on(el, "incomplete", opts.onincomplete),
|
||
EventRuler.on(el, "cleared", opts.oncleared),
|
||
android || !0 === opts.inputEventOnly
|
||
? el.removeAttribute("maxLength")
|
||
: (EventRuler.on(el, "keydown", EventHandlers.keydownEvent),
|
||
EventRuler.on(el, "keypress", EventHandlers.keypressEvent)),
|
||
EventRuler.on(el, "compositionstart", $.noop),
|
||
EventRuler.on(el, "compositionupdate", $.noop),
|
||
EventRuler.on(el, "compositionend", $.noop),
|
||
EventRuler.on(el, "keyup", $.noop),
|
||
EventRuler.on(el, "input", EventHandlers.inputFallBackEvent),
|
||
EventRuler.on(el, "beforeinput", $.noop)),
|
||
EventRuler.on(el, "setvalue", EventHandlers.setValueEvent),
|
||
(undoValue = getBufferTemplate().join("")),
|
||
"" !== el.inputmask._valueGet(!0) ||
|
||
!1 === opts.clearMaskOnLostFocus ||
|
||
document.activeElement === el)
|
||
) {
|
||
var initialValue = $.isFunction(opts.onBeforeMask)
|
||
? opts.onBeforeMask.call(
|
||
inputmask,
|
||
el.inputmask._valueGet(!0),
|
||
opts
|
||
) || el.inputmask._valueGet(!0)
|
||
: el.inputmask._valueGet(!0);
|
||
"" !== initialValue &&
|
||
checkVal(
|
||
el,
|
||
!0,
|
||
!1,
|
||
isRTL
|
||
? initialValue.split("").reverse()
|
||
: initialValue.split("")
|
||
);
|
||
var buffer = getBuffer().slice();
|
||
(undoValue = buffer.join("")),
|
||
!1 === isComplete(buffer) &&
|
||
opts.clearIncomplete &&
|
||
resetMaskSet(),
|
||
opts.clearMaskOnLostFocus &&
|
||
document.activeElement !== el &&
|
||
(-1 === getLastValidPosition()
|
||
? (buffer = [])
|
||
: clearOptionalTail(buffer)),
|
||
writeBuffer(el, buffer),
|
||
document.activeElement === el &&
|
||
caret(el, seekNext(getLastValidPosition()));
|
||
}
|
||
})(el);
|
||
break;
|
||
|
||
case "format":
|
||
return (
|
||
(valueBuffer = (
|
||
$.isFunction(opts.onBeforeMask)
|
||
? opts.onBeforeMask.call(inputmask, actionObj.value, opts) ||
|
||
actionObj.value
|
||
: actionObj.value
|
||
).split("")),
|
||
checkVal(
|
||
undefined,
|
||
!0,
|
||
!1,
|
||
isRTL ? valueBuffer.reverse() : valueBuffer
|
||
),
|
||
actionObj.metadata
|
||
? {
|
||
value: isRTL
|
||
? getBuffer().slice().reverse().join("")
|
||
: getBuffer().join(""),
|
||
metadata: maskScope.call(
|
||
this,
|
||
{
|
||
action: "getmetadata",
|
||
},
|
||
maskset,
|
||
opts
|
||
),
|
||
}
|
||
: isRTL
|
||
? getBuffer().slice().reverse().join("")
|
||
: getBuffer().join("")
|
||
);
|
||
|
||
case "isValid":
|
||
actionObj.value
|
||
? ((valueBuffer = actionObj.value.split("")),
|
||
checkVal(
|
||
undefined,
|
||
!0,
|
||
!0,
|
||
isRTL ? valueBuffer.reverse() : valueBuffer
|
||
))
|
||
: (actionObj.value = getBuffer().join(""));
|
||
for (
|
||
var buffer = getBuffer(),
|
||
rl = determineLastRequiredPosition(),
|
||
lmib = buffer.length - 1;
|
||
lmib > rl && !isMask(lmib);
|
||
lmib--
|
||
);
|
||
return (
|
||
buffer.splice(rl, lmib + 1 - rl),
|
||
isComplete(buffer) && actionObj.value === getBuffer().join("")
|
||
);
|
||
|
||
case "getemptymask":
|
||
return getBufferTemplate().join("");
|
||
|
||
case "remove":
|
||
if (el && el.inputmask) {
|
||
($el = $(el)),
|
||
el.inputmask._valueSet(
|
||
opts.autoUnmask ? unmaskedvalue(el) : el.inputmask._valueGet(!0)
|
||
),
|
||
EventRuler.off(el);
|
||
Object.getOwnPropertyDescriptor && Object.getPrototypeOf
|
||
? Object.getOwnPropertyDescriptor(
|
||
Object.getPrototypeOf(el),
|
||
"value"
|
||
) &&
|
||
el.inputmask.__valueGet &&
|
||
Object.defineProperty(el, "value", {
|
||
get: el.inputmask.__valueGet,
|
||
set: el.inputmask.__valueSet,
|
||
configurable: !0,
|
||
})
|
||
: document.__lookupGetter__ &&
|
||
el.__lookupGetter__("value") &&
|
||
el.inputmask.__valueGet &&
|
||
(el.__defineGetter__("value", el.inputmask.__valueGet),
|
||
el.__defineSetter__("value", el.inputmask.__valueSet)),
|
||
(el.inputmask = undefined);
|
||
}
|
||
return el;
|
||
|
||
case "getmetadata":
|
||
if ($.isArray(maskset.metadata)) {
|
||
var maskTarget = getMaskTemplate(!0, 0, !1).join("");
|
||
return (
|
||
$.each(maskset.metadata, function (ndx, mtdt) {
|
||
if (mtdt.mask === maskTarget) return (maskTarget = mtdt), !1;
|
||
}),
|
||
maskTarget
|
||
);
|
||
}
|
||
return maskset.metadata;
|
||
}
|
||
}
|
||
var ua = navigator.userAgent,
|
||
mobile = /mobile/i.test(ua),
|
||
iemobile = /iemobile/i.test(ua),
|
||
iphone = /iphone/i.test(ua) && !iemobile,
|
||
android = /android/i.test(ua) && !iemobile;
|
||
return (
|
||
(Inputmask.prototype = {
|
||
dataAttribute: "data-inputmask",
|
||
defaults: {
|
||
placeholder: "_",
|
||
optionalmarker: {
|
||
start: "[",
|
||
end: "]",
|
||
},
|
||
quantifiermarker: {
|
||
start: "{",
|
||
end: "}",
|
||
},
|
||
groupmarker: {
|
||
start: "(",
|
||
end: ")",
|
||
},
|
||
alternatormarker: "|",
|
||
escapeChar: "\\",
|
||
mask: null,
|
||
regex: null,
|
||
oncomplete: $.noop,
|
||
onincomplete: $.noop,
|
||
oncleared: $.noop,
|
||
repeat: 0,
|
||
greedy: !0,
|
||
autoUnmask: !1,
|
||
removeMaskOnSubmit: !1,
|
||
clearMaskOnLostFocus: !0,
|
||
insertMode: !0,
|
||
clearIncomplete: !1,
|
||
alias: null,
|
||
onKeyDown: $.noop,
|
||
onBeforeMask: null,
|
||
onBeforePaste: function (pastedValue, opts) {
|
||
return $.isFunction(opts.onBeforeMask)
|
||
? opts.onBeforeMask.call(this, pastedValue, opts)
|
||
: pastedValue;
|
||
},
|
||
onBeforeWrite: null,
|
||
onUnMask: null,
|
||
showMaskOnFocus: !0,
|
||
showMaskOnHover: !0,
|
||
onKeyValidation: $.noop,
|
||
skipOptionalPartCharacter: " ",
|
||
numericInput: !1,
|
||
rightAlign: !1,
|
||
undoOnEscape: !0,
|
||
radixPoint: "",
|
||
radixPointDefinitionSymbol: undefined,
|
||
groupSeparator: "",
|
||
keepStatic: null,
|
||
positionCaretOnTab: !0,
|
||
tabThrough: !1,
|
||
supportsInputType: ["text", "tel", "password"],
|
||
ignorables: [
|
||
8, 9, 13, 19, 27, 33, 34, 35, 36, 37, 38, 39, 40, 45, 46, 93, 112,
|
||
113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 0, 229,
|
||
],
|
||
isComplete: null,
|
||
canClearPosition: $.noop,
|
||
preValidation: null,
|
||
postValidation: null,
|
||
staticDefinitionSymbol: undefined,
|
||
jitMasking: !1,
|
||
nullable: !0,
|
||
inputEventOnly: !1,
|
||
noValuePatching: !1,
|
||
positionCaretOnClick: "lvp",
|
||
casing: null,
|
||
inputmode: "verbatim",
|
||
colorMask: !1,
|
||
androidHack: !1,
|
||
importDataAttributes: !0,
|
||
},
|
||
definitions: {
|
||
9: {
|
||
validator: "[0-9１-９]",
|
||
cardinality: 1,
|
||
definitionSymbol: "*",
|
||
},
|
||
a: {
|
||
validator: "[A-Za-zА-яЁёÀ-ÿµ]",
|
||
cardinality: 1,
|
||
definitionSymbol: "*",
|
||
},
|
||
"*": {
|
||
validator: "[0-9１-９A-Za-zА-яЁёÀ-ÿµ]",
|
||
cardinality: 1,
|
||
},
|
||
},
|
||
aliases: {},
|
||
masksCache: {},
|
||
mask: function (elems) {
|
||
function importAttributeOptions(npt, opts, userOptions, dataAttribute) {
|
||
function importOption(option, optionData) {
|
||
null !==
|
||
(optionData =
|
||
optionData !== undefined
|
||
? optionData
|
||
: npt.getAttribute(dataAttribute + "-" + option)) &&
|
||
("string" == typeof optionData &&
|
||
(0 === option.indexOf("on")
|
||
? (optionData = window[optionData])
|
||
: "false" === optionData
|
||
? (optionData = !1)
|
||
: "true" === optionData && (optionData = !0)),
|
||
(userOptions[option] = optionData));
|
||
}
|
||
if (!0 === opts.importDataAttributes) {
|
||
var option,
|
||
dataoptions,
|
||
optionData,
|
||
p,
|
||
attrOptions = npt.getAttribute(dataAttribute);
|
||
if (
|
||
(attrOptions &&
|
||
"" !== attrOptions &&
|
||
((attrOptions = attrOptions.replace(new RegExp("'", "g"), '"')),
|
||
(dataoptions = JSON.parse("{" + attrOptions + "}"))),
|
||
dataoptions)
|
||
) {
|
||
optionData = undefined;
|
||
for (p in dataoptions)
|
||
if ("alias" === p.toLowerCase()) {
|
||
optionData = dataoptions[p];
|
||
break;
|
||
}
|
||
}
|
||
importOption("alias", optionData),
|
||
userOptions.alias &&
|
||
resolveAlias(userOptions.alias, userOptions, opts);
|
||
for (option in opts) {
|
||
if (dataoptions) {
|
||
optionData = undefined;
|
||
for (p in dataoptions)
|
||
if (p.toLowerCase() === option.toLowerCase()) {
|
||
optionData = dataoptions[p];
|
||
break;
|
||
}
|
||
}
|
||
importOption(option, optionData);
|
||
}
|
||
}
|
||
return (
|
||
$.extend(!0, opts, userOptions),
|
||
("rtl" === npt.dir || opts.rightAlign) &&
|
||
(npt.style.textAlign = "right"),
|
||
("rtl" === npt.dir || opts.numericInput) &&
|
||
((npt.dir = "ltr"),
|
||
npt.removeAttribute("dir"),
|
||
(opts.isRTL = !0)),
|
||
opts
|
||
);
|
||
}
|
||
var that = this;
|
||
return (
|
||
"string" == typeof elems &&
|
||
(elems =
|
||
document.getElementById(elems) ||
|
||
document.querySelectorAll(elems)),
|
||
(elems = elems.nodeName ? [elems] : elems),
|
||
$.each(elems, function (ndx, el) {
|
||
var scopedOpts = $.extend(!0, {}, that.opts);
|
||
importAttributeOptions(
|
||
el,
|
||
scopedOpts,
|
||
$.extend(!0, {}, that.userOptions),
|
||
that.dataAttribute
|
||
);
|
||
var maskset = generateMaskSet(scopedOpts, that.noMasksCache);
|
||
maskset !== undefined &&
|
||
(el.inputmask !== undefined &&
|
||
((el.inputmask.opts.autoUnmask = !0), el.inputmask.remove()),
|
||
(el.inputmask = new Inputmask(undefined, undefined, !0)),
|
||
(el.inputmask.opts = scopedOpts),
|
||
(el.inputmask.noMasksCache = that.noMasksCache),
|
||
(el.inputmask.userOptions = $.extend(!0, {}, that.userOptions)),
|
||
(el.inputmask.isRTL =
|
||
scopedOpts.isRTL || scopedOpts.numericInput),
|
||
(el.inputmask.el = el),
|
||
(el.inputmask.maskset = maskset),
|
||
$.data(el, "_inputmask_opts", scopedOpts),
|
||
maskScope.call(el.inputmask, {
|
||
action: "mask",
|
||
}));
|
||
}),
|
||
elems && elems[0] ? elems[0].inputmask || this : this
|
||
);
|
||
},
|
||
option: function (options, noremask) {
|
||
return "string" == typeof options
|
||
? this.opts[options]
|
||
: "object" == typeof options
|
||
? ($.extend(this.userOptions, options),
|
||
this.el && !0 !== noremask && this.mask(this.el),
|
||
this)
|
||
: void 0;
|
||
},
|
||
unmaskedvalue: function (value) {
|
||
return (
|
||
(this.maskset =
|
||
this.maskset || generateMaskSet(this.opts, this.noMasksCache)),
|
||
maskScope.call(this, {
|
||
action: "unmaskedvalue",
|
||
value: value,
|
||
})
|
||
);
|
||
},
|
||
remove: function () {
|
||
return maskScope.call(this, {
|
||
action: "remove",
|
||
});
|
||
},
|
||
getemptymask: function () {
|
||
return (
|
||
(this.maskset =
|
||
this.maskset || generateMaskSet(this.opts, this.noMasksCache)),
|
||
maskScope.call(this, {
|
||
action: "getemptymask",
|
||
})
|
||
);
|
||
},
|
||
hasMaskedValue: function () {
|
||
return !this.opts.autoUnmask;
|
||
},
|
||
isComplete: function () {
|
||
return (
|
||
(this.maskset =
|
||
this.maskset || generateMaskSet(this.opts, this.noMasksCache)),
|
||
maskScope.call(this, {
|
||
action: "isComplete",
|
||
})
|
||
);
|
||
},
|
||
getmetadata: function () {
|
||
return (
|
||
(this.maskset =
|
||
this.maskset || generateMaskSet(this.opts, this.noMasksCache)),
|
||
maskScope.call(this, {
|
||
action: "getmetadata",
|
||
})
|
||
);
|
||
},
|
||
isValid: function (value) {
|
||
return (
|
||
(this.maskset =
|
||
this.maskset || generateMaskSet(this.opts, this.noMasksCache)),
|
||
maskScope.call(this, {
|
||
action: "isValid",
|
||
value: value,
|
||
})
|
||
);
|
||
},
|
||
format: function (value, metadata) {
|
||
return (
|
||
(this.maskset =
|
||
this.maskset || generateMaskSet(this.opts, this.noMasksCache)),
|
||
maskScope.call(this, {
|
||
action: "format",
|
||
value: value,
|
||
metadata: metadata,
|
||
})
|
||
);
|
||
},
|
||
analyseMask: function (mask, regexMask, opts) {
|
||
function MaskToken(isGroup, isOptional, isQuantifier, isAlternator) {
|
||
(this.matches = []),
|
||
(this.openGroup = isGroup || !1),
|
||
(this.alternatorGroup = !1),
|
||
(this.isGroup = isGroup || !1),
|
||
(this.isOptional = isOptional || !1),
|
||
(this.isQuantifier = isQuantifier || !1),
|
||
(this.isAlternator = isAlternator || !1),
|
||
(this.quantifier = {
|
||
min: 1,
|
||
max: 1,
|
||
});
|
||
}
|
||
function insertTestDefinition(mtoken, element, position) {
|
||
position = position !== undefined ? position : mtoken.matches.length;
|
||
var prevMatch = mtoken.matches[position - 1];
|
||
if (regexMask)
|
||
0 === element.indexOf("[") ||
|
||
(escaped && /\\d|\\s|\\w]/i.test(element)) ||
|
||
"." === element
|
||
? mtoken.matches.splice(position++, 0, {
|
||
fn: new RegExp(element, opts.casing ? "i" : ""),
|
||
cardinality: 1,
|
||
optionality: mtoken.isOptional,
|
||
newBlockMarker:
|
||
prevMatch === undefined || prevMatch.def !== element,
|
||
casing: null,
|
||
def: element,
|
||
placeholder: undefined,
|
||
nativeDef: element,
|
||
})
|
||
: (escaped && (element = element[element.length - 1]),
|
||
$.each(element.split(""), function (ndx, lmnt) {
|
||
(prevMatch = mtoken.matches[position - 1]),
|
||
mtoken.matches.splice(position++, 0, {
|
||
fn: null,
|
||
cardinality: 0,
|
||
optionality: mtoken.isOptional,
|
||
newBlockMarker:
|
||
prevMatch === undefined ||
|
||
(prevMatch.def !== lmnt && null !== prevMatch.fn),
|
||
casing: null,
|
||
def: opts.staticDefinitionSymbol || lmnt,
|
||
placeholder:
|
||
opts.staticDefinitionSymbol !== undefined
|
||
? lmnt
|
||
: undefined,
|
||
nativeDef: lmnt,
|
||
});
|
||
})),
|
||
(escaped = !1);
|
||
else {
|
||
var maskdef =
|
||
(opts.definitions ? opts.definitions[element] : undefined) ||
|
||
Inputmask.prototype.definitions[element];
|
||
if (maskdef && !escaped) {
|
||
for (
|
||
var prevalidators = maskdef.prevalidator,
|
||
prevalidatorsL = prevalidators ? prevalidators.length : 0,
|
||
i = 1;
|
||
i < maskdef.cardinality;
|
||
i++
|
||
) {
|
||
var prevalidator =
|
||
prevalidatorsL >= i ? prevalidators[i - 1] : [],
|
||
validator = prevalidator.validator,
|
||
cardinality = prevalidator.cardinality;
|
||
mtoken.matches.splice(position++, 0, {
|
||
fn: validator
|
||
? "string" == typeof validator
|
||
? new RegExp(validator, opts.casing ? "i" : "")
|
||
: new (function () {
|
||
this.test = validator;
|
||
})()
|
||
: new RegExp("."),
|
||
cardinality: cardinality || 1,
|
||
optionality: mtoken.isOptional,
|
||
newBlockMarker:
|
||
prevMatch === undefined ||
|
||
prevMatch.def !== (maskdef.definitionSymbol || element),
|
||
casing: maskdef.casing,
|
||
def: maskdef.definitionSymbol || element,
|
||
placeholder: maskdef.placeholder,
|
||
nativeDef: element,
|
||
}),
|
||
(prevMatch = mtoken.matches[position - 1]);
|
||
}
|
||
mtoken.matches.splice(position++, 0, {
|
||
fn: maskdef.validator
|
||
? "string" == typeof maskdef.validator
|
||
? new RegExp(maskdef.validator, opts.casing ? "i" : "")
|
||
: new (function () {
|
||
this.test = maskdef.validator;
|
||
})()
|
||
: new RegExp("."),
|
||
cardinality: maskdef.cardinality,
|
||
optionality: mtoken.isOptional,
|
||
newBlockMarker:
|
||
prevMatch === undefined ||
|
||
prevMatch.def !== (maskdef.definitionSymbol || element),
|
||
casing: maskdef.casing,
|
||
def: maskdef.definitionSymbol || element,
|
||
placeholder: maskdef.placeholder,
|
||
nativeDef: element,
|
||
});
|
||
} else
|
||
mtoken.matches.splice(position++, 0, {
|
||
fn: null,
|
||
cardinality: 0,
|
||
optionality: mtoken.isOptional,
|
||
newBlockMarker:
|
||
prevMatch === undefined ||
|
||
(prevMatch.def !== element && null !== prevMatch.fn),
|
||
casing: null,
|
||
def: opts.staticDefinitionSymbol || element,
|
||
placeholder:
|
||
opts.staticDefinitionSymbol !== undefined
|
||
? element
|
||
: undefined,
|
||
nativeDef: element,
|
||
}),
|
||
(escaped = !1);
|
||
}
|
||
}
|
||
function verifyGroupMarker(maskToken) {
|
||
maskToken &&
|
||
maskToken.matches &&
|
||
$.each(maskToken.matches, function (ndx, token) {
|
||
var nextToken = maskToken.matches[ndx + 1];
|
||
(nextToken === undefined ||
|
||
nextToken.matches === undefined ||
|
||
!1 === nextToken.isQuantifier) &&
|
||
token &&
|
||
token.isGroup &&
|
||
((token.isGroup = !1),
|
||
regexMask ||
|
||
(insertTestDefinition(token, opts.groupmarker.start, 0),
|
||
!0 !== token.openGroup &&
|
||
insertTestDefinition(token, opts.groupmarker.end))),
|
||
verifyGroupMarker(token);
|
||
});
|
||
}
|
||
function defaultCase() {
|
||
if (openenings.length > 0) {
|
||
if (
|
||
((currentOpeningToken = openenings[openenings.length - 1]),
|
||
insertTestDefinition(currentOpeningToken, m),
|
||
currentOpeningToken.isAlternator)
|
||
) {
|
||
alternator = openenings.pop();
|
||
for (var mndx = 0; mndx < alternator.matches.length; mndx++)
|
||
alternator.matches[mndx].isGroup = !1;
|
||
openenings.length > 0
|
||
? (currentOpeningToken =
|
||
openenings[openenings.length - 1]).matches.push(alternator)
|
||
: currentToken.matches.push(alternator);
|
||
}
|
||
} else insertTestDefinition(currentToken, m);
|
||
}
|
||
function reverseTokens(maskToken) {
|
||
maskToken.matches = maskToken.matches.reverse();
|
||
for (var match in maskToken.matches)
|
||
if (maskToken.matches.hasOwnProperty(match)) {
|
||
var intMatch = parseInt(match);
|
||
if (
|
||
maskToken.matches[match].isQuantifier &&
|
||
maskToken.matches[intMatch + 1] &&
|
||
maskToken.matches[intMatch + 1].isGroup
|
||
) {
|
||
var qt = maskToken.matches[match];
|
||
maskToken.matches.splice(match, 1),
|
||
maskToken.matches.splice(intMatch + 1, 0, qt);
|
||
}
|
||
maskToken.matches[match].matches !== undefined
|
||
? (maskToken.matches[match] = reverseTokens(
|
||
maskToken.matches[match]
|
||
))
|
||
: (maskToken.matches[match] = (function (st) {
|
||
return (
|
||
st === opts.optionalmarker.start
|
||
? (st = opts.optionalmarker.end)
|
||
: st === opts.optionalmarker.end
|
||
? (st = opts.optionalmarker.start)
|
||
: st === opts.groupmarker.start
|
||
? (st = opts.groupmarker.end)
|
||
: st === opts.groupmarker.end &&
|
||
(st = opts.groupmarker.start),
|
||
st
|
||
);
|
||
})(maskToken.matches[match]));
|
||
}
|
||
return maskToken;
|
||
}
|
||
var match,
|
||
m,
|
||
openingToken,
|
||
currentOpeningToken,
|
||
alternator,
|
||
lastMatch,
|
||
groupToken,
|
||
tokenizer =
|
||
/(?:[?*+]|\{[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(),
|
||
openenings = [],
|
||
maskTokens = [];
|
||
for (
|
||
regexMask &&
|
||
((opts.optionalmarker.start = undefined),
|
||
(opts.optionalmarker.end = undefined));
|
||
(match = regexMask
|
||
? regexTokenizer.exec(mask)
|
||
: tokenizer.exec(mask));
|
||
|
||
) {
|
||
if (((m = match[0]), regexMask))
|
||
switch (m.charAt(0)) {
|
||
case "?":
|
||
m = "{0,1}";
|
||
break;
|
||
|
||
case "+":
|
||
case "*":
|
||
m = "{" + m + "}";
|
||
}
|
||
if (escaped) defaultCase();
|
||
else
|
||
switch (m.charAt(0)) {
|
||
case opts.escapeChar:
|
||
(escaped = !0), regexMask && defaultCase();
|
||
break;
|
||
|
||
case opts.optionalmarker.end:
|
||
case opts.groupmarker.end:
|
||
if (
|
||
((openingToken = openenings.pop()),
|
||
(openingToken.openGroup = !1),
|
||
openingToken !== undefined)
|
||
)
|
||
if (openenings.length > 0) {
|
||
if (
|
||
((currentOpeningToken =
|
||
openenings[openenings.length - 1]).matches.push(
|
||
openingToken
|
||
),
|
||
currentOpeningToken.isAlternator)
|
||
) {
|
||
alternator = openenings.pop();
|
||
for (
|
||
var mndx = 0;
|
||
mndx < alternator.matches.length;
|
||
mndx++
|
||
)
|
||
(alternator.matches[mndx].isGroup = !1),
|
||
(alternator.matches[mndx].alternatorGroup = !1);
|
||
openenings.length > 0
|
||
? (currentOpeningToken =
|
||
openenings[openenings.length - 1]).matches.push(
|
||
alternator
|
||
)
|
||
: currentToken.matches.push(alternator);
|
||
}
|
||
} else currentToken.matches.push(openingToken);
|
||
else defaultCase();
|
||
break;
|
||
|
||
case opts.optionalmarker.start:
|
||
openenings.push(new MaskToken(!1, !0));
|
||
break;
|
||
|
||
case opts.groupmarker.start:
|
||
openenings.push(new MaskToken(!0));
|
||
break;
|
||
|
||
case opts.quantifiermarker.start:
|
||
var quantifier = new MaskToken(!1, !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 (
|
||
(("*" !== mq1 && "+" !== mq1) || (mq0 = "*" === mq1 ? 0 : 1),
|
||
(quantifier.quantifier = {
|
||
min: mq0,
|
||
max: mq1,
|
||
}),
|
||
openenings.length > 0)
|
||
) {
|
||
var matches = openenings[openenings.length - 1].matches;
|
||
(match = matches.pop()).isGroup ||
|
||
((groupToken = new MaskToken(!0)).matches.push(match),
|
||
(match = groupToken)),
|
||
matches.push(match),
|
||
matches.push(quantifier);
|
||
} else
|
||
(match = currentToken.matches.pop()).isGroup ||
|
||
(regexMask &&
|
||
null === match.fn &&
|
||
"." === match.def &&
|
||
(match.fn = new RegExp(
|
||
match.def,
|
||
opts.casing ? "i" : ""
|
||
)),
|
||
(groupToken = new MaskToken(!0)).matches.push(match),
|
||
(match = groupToken)),
|
||
currentToken.matches.push(match),
|
||
currentToken.matches.push(quantifier);
|
||
break;
|
||
|
||
case opts.alternatormarker:
|
||
if (openenings.length > 0) {
|
||
var subToken = (currentOpeningToken =
|
||
openenings[openenings.length - 1]).matches[
|
||
currentOpeningToken.matches.length - 1
|
||
];
|
||
lastMatch =
|
||
currentOpeningToken.openGroup &&
|
||
(subToken.matches === undefined ||
|
||
(!1 === subToken.isGroup && !1 === subToken.isAlternator))
|
||
? openenings.pop()
|
||
: currentOpeningToken.matches.pop();
|
||
} else lastMatch = currentToken.matches.pop();
|
||
if (lastMatch.isAlternator) openenings.push(lastMatch);
|
||
else if (
|
||
(lastMatch.alternatorGroup
|
||
? ((alternator = openenings.pop()),
|
||
(lastMatch.alternatorGroup = !1))
|
||
: (alternator = new MaskToken(!1, !1, !1, !0)),
|
||
alternator.matches.push(lastMatch),
|
||
openenings.push(alternator),
|
||
lastMatch.openGroup)
|
||
) {
|
||
lastMatch.openGroup = !1;
|
||
var alternatorGroup = new MaskToken(!0);
|
||
(alternatorGroup.alternatorGroup = !0),
|
||
openenings.push(alternatorGroup);
|
||
}
|
||
break;
|
||
|
||
default:
|
||
defaultCase();
|
||
}
|
||
}
|
||
for (; openenings.length > 0; )
|
||
(openingToken = openenings.pop()),
|
||
currentToken.matches.push(openingToken);
|
||
return (
|
||
currentToken.matches.length > 0 &&
|
||
(verifyGroupMarker(currentToken), maskTokens.push(currentToken)),
|
||
(opts.numericInput || opts.isRTL) && reverseTokens(maskTokens[0]),
|
||
maskTokens
|
||
);
|
||
},
|
||
}),
|
||
(Inputmask.extendDefaults = function (options) {
|
||
$.extend(!0, Inputmask.prototype.defaults, options);
|
||
}),
|
||
(Inputmask.extendDefinitions = function (definition) {
|
||
$.extend(!0, Inputmask.prototype.definitions, definition);
|
||
}),
|
||
(Inputmask.extendAliases = function (alias) {
|
||
$.extend(!0, Inputmask.prototype.aliases, alias);
|
||
}),
|
||
(Inputmask.format = function (value, options, metadata) {
|
||
return Inputmask(options).format(value, metadata);
|
||
}),
|
||
(Inputmask.unmask = function (value, options) {
|
||
return Inputmask(options).unmaskedvalue(value);
|
||
}),
|
||
(Inputmask.isValid = function (value, options) {
|
||
return Inputmask(options).isValid(value);
|
||
}),
|
||
(Inputmask.remove = function (elems) {
|
||
$.each(elems, function (ndx, el) {
|
||
el.inputmask && el.inputmask.remove();
|
||
});
|
||
}),
|
||
(Inputmask.escapeRegex = function (str) {
|
||
var specials = [
|
||
"/",
|
||
".",
|
||
"*",
|
||
"+",
|
||
"?",
|
||
"|",
|
||
"(",
|
||
")",
|
||
"[",
|
||
"]",
|
||
"{",
|
||
"}",
|
||
"\\",
|
||
"$",
|
||
"^",
|
||
];
|
||
return str.replace(
|
||
new RegExp("(\\" + specials.join("|\\") + ")", "gim"),
|
||
"\\$1"
|
||
);
|
||
}),
|
||
(Inputmask.keyCode = {
|
||
ALT: 18,
|
||
BACKSPACE: 8,
|
||
BACKSPACE_SAFARI: 127,
|
||
CAPS_LOCK: 20,
|
||
COMMA: 188,
|
||
COMMAND: 91,
|
||
COMMAND_LEFT: 91,
|
||
COMMAND_RIGHT: 93,
|
||
CONTROL: 17,
|
||
DELETE: 46,
|
||
DOWN: 40,
|
||
END: 35,
|
||
ENTER: 13,
|
||
ESCAPE: 27,
|
||
HOME: 36,
|
||
INSERT: 45,
|
||
LEFT: 37,
|
||
MENU: 93,
|
||
NUMPAD_ADD: 107,
|
||
NUMPAD_DECIMAL: 110,
|
||
NUMPAD_DIVIDE: 111,
|
||
NUMPAD_ENTER: 108,
|
||
NUMPAD_MULTIPLY: 106,
|
||
NUMPAD_SUBTRACT: 109,
|
||
PAGE_DOWN: 34,
|
||
PAGE_UP: 33,
|
||
PERIOD: 190,
|
||
RIGHT: 39,
|
||
SHIFT: 16,
|
||
SPACE: 32,
|
||
TAB: 9,
|
||
UP: 38,
|
||
WINDOWS: 91,
|
||
X: 88,
|
||
}),
|
||
Inputmask
|
||
);
|
||
});
|