7010 lines
277 KiB
JavaScript
7010 lines
277 KiB
JavaScript
/*!
|
||
* jquery.inputmask.bundle.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 (modules) {
|
||
function __webpack_require__(moduleId) {
|
||
if (installedModules[moduleId]) return installedModules[moduleId].exports;
|
||
var module = (installedModules[moduleId] = {
|
||
i: moduleId,
|
||
l: !1,
|
||
exports: {},
|
||
});
|
||
return (
|
||
modules[moduleId].call(
|
||
module.exports,
|
||
module,
|
||
module.exports,
|
||
__webpack_require__
|
||
),
|
||
(module.l = !0),
|
||
module.exports
|
||
);
|
||
}
|
||
var installedModules = {};
|
||
(__webpack_require__.m = modules),
|
||
(__webpack_require__.c = installedModules),
|
||
(__webpack_require__.d = function (exports, name, getter) {
|
||
__webpack_require__.o(exports, name) ||
|
||
Object.defineProperty(exports, name, {
|
||
configurable: !1,
|
||
enumerable: !0,
|
||
get: getter,
|
||
});
|
||
}),
|
||
(__webpack_require__.n = function (module) {
|
||
var getter =
|
||
module && module.__esModule
|
||
? function () {
|
||
return module.default;
|
||
}
|
||
: function () {
|
||
return module;
|
||
};
|
||
return __webpack_require__.d(getter, "a", getter), getter;
|
||
}),
|
||
(__webpack_require__.o = function (object, property) {
|
||
return Object.prototype.hasOwnProperty.call(object, property);
|
||
}),
|
||
(__webpack_require__.p = ""),
|
||
__webpack_require__((__webpack_require__.s = 3));
|
||
})([
|
||
function (module, exports, __webpack_require__) {
|
||
"use strict";
|
||
var __WEBPACK_AMD_DEFINE_FACTORY__,
|
||
__WEBPACK_AMD_DEFINE_ARRAY__,
|
||
__WEBPACK_AMD_DEFINE_RESULT__;
|
||
"function" == typeof Symbol && Symbol.iterator;
|
||
!(function (factory) {
|
||
(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(2)]),
|
||
void 0 !==
|
||
(__WEBPACK_AMD_DEFINE_RESULT__ =
|
||
"function" == typeof (__WEBPACK_AMD_DEFINE_FACTORY__ = factory)
|
||
? __WEBPACK_AMD_DEFINE_FACTORY__.apply(
|
||
exports,
|
||
__WEBPACK_AMD_DEFINE_ARRAY__
|
||
)
|
||
: __WEBPACK_AMD_DEFINE_FACTORY__) &&
|
||
(module.exports = __WEBPACK_AMD_DEFINE_RESULT__);
|
||
})(function ($) {
|
||
return $;
|
||
});
|
||
},
|
||
function (module, exports, __webpack_require__) {
|
||
"use strict";
|
||
var __WEBPACK_AMD_DEFINE_FACTORY__,
|
||
__WEBPACK_AMD_DEFINE_ARRAY__,
|
||
__WEBPACK_AMD_DEFINE_RESULT__,
|
||
_typeof =
|
||
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
|
||
? function (obj) {
|
||
return typeof obj;
|
||
}
|
||
: function (obj) {
|
||
return obj &&
|
||
"function" == typeof Symbol &&
|
||
obj.constructor === Symbol &&
|
||
obj !== Symbol.prototype
|
||
? "symbol"
|
||
: typeof obj;
|
||
};
|
||
!(function (factory) {
|
||
(__WEBPACK_AMD_DEFINE_ARRAY__ = [
|
||
__webpack_require__(0),
|
||
__webpack_require__(10),
|
||
__webpack_require__(11),
|
||
]),
|
||
void 0 !==
|
||
(__WEBPACK_AMD_DEFINE_RESULT__ =
|
||
"function" == typeof (__WEBPACK_AMD_DEFINE_FACTORY__ = factory)
|
||
? __WEBPACK_AMD_DEFINE_FACTORY__.apply(
|
||
exports,
|
||
__WEBPACK_AMD_DEFINE_ARRAY__
|
||
)
|
||
: __WEBPACK_AMD_DEFINE_FACTORY__) &&
|
||
(module.exports = __WEBPACK_AMD_DEFINE_RESULT__);
|
||
})(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
|
||
) {
|
||
if (!0 === opts.importDataAttributes) {
|
||
var option,
|
||
dataoptions,
|
||
optionData,
|
||
p,
|
||
importOption = function (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));
|
||
},
|
||
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" ===
|
||
(void 0 === options ? "undefined" : _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
|
||
);
|
||
});
|
||
},
|
||
function (module, exports) {
|
||
module.exports = jQuery;
|
||
},
|
||
function (module, exports, __webpack_require__) {
|
||
"use strict";
|
||
function _interopRequireDefault(obj) {
|
||
return obj && obj.__esModule
|
||
? obj
|
||
: {
|
||
default: obj,
|
||
};
|
||
}
|
||
__webpack_require__(4),
|
||
__webpack_require__(9),
|
||
__webpack_require__(12),
|
||
__webpack_require__(13),
|
||
__webpack_require__(14),
|
||
__webpack_require__(15);
|
||
var _inputmask2 = _interopRequireDefault(__webpack_require__(1)),
|
||
_inputmask4 = _interopRequireDefault(__webpack_require__(0)),
|
||
_jquery2 = _interopRequireDefault(__webpack_require__(2));
|
||
_inputmask4.default === _jquery2.default && __webpack_require__(16),
|
||
(window.Inputmask = _inputmask2.default);
|
||
},
|
||
function (module, exports, __webpack_require__) {
|
||
var content = __webpack_require__(5);
|
||
"string" == typeof content && (content = [[module.i, content, ""]]);
|
||
var options = {
|
||
hmr: !0,
|
||
};
|
||
options.transform = void 0;
|
||
__webpack_require__(7)(content, options);
|
||
content.locals && (module.exports = content.locals);
|
||
},
|
||
function (module, exports, __webpack_require__) {
|
||
(module.exports = __webpack_require__(6)(void 0)).push([
|
||
module.i,
|
||
"span.im-caret {\r\n -webkit-animation: 1s blink step-end infinite;\r\n animation: 1s blink step-end infinite;\r\n}\r\n\r\n@keyframes blink {\r\n from, to {\r\n border-right-color: black;\r\n }\r\n 50% {\r\n border-right-color: transparent;\r\n }\r\n}\r\n\r\n@-webkit-keyframes blink {\r\n from, to {\r\n border-right-color: black;\r\n }\r\n 50% {\r\n border-right-color: transparent;\r\n }\r\n}\r\n\r\nspan.im-static {\r\n color: grey;\r\n}\r\n\r\ndiv.im-colormask {\r\n display: inline-block;\r\n border-style: inset;\r\n border-width: 2px;\r\n -webkit-appearance: textfield;\r\n -moz-appearance: textfield;\r\n appearance: textfield;\r\n}\r\n\r\ndiv.im-colormask > input {\r\n position: absolute;\r\n display: inline-block;\r\n background-color: transparent;\r\n color: transparent;\r\n -webkit-appearance: caret;\r\n -moz-appearance: caret;\r\n appearance: caret;\r\n border-style: none;\r\n left: 0; /*calculated*/\r\n}\r\n\r\ndiv.im-colormask > input:focus {\r\n outline: none;\r\n}\r\n\r\ndiv.im-colormask > input::-moz-selection{\r\n background: none;\r\n}\r\n\r\ndiv.im-colormask > input::selection{\r\n background: none;\r\n}\r\ndiv.im-colormask > input::-moz-selection{\r\n background: none;\r\n}\r\n\r\ndiv.im-colormask > div {\r\n color: black;\r\n display: inline-block;\r\n width: 100px; /*calculated*/\r\n}",
|
||
"",
|
||
]);
|
||
},
|
||
function (module, exports) {
|
||
function cssWithMappingToString(item, useSourceMap) {
|
||
var content = item[1] || "",
|
||
cssMapping = item[3];
|
||
if (!cssMapping) return content;
|
||
if (useSourceMap && "function" == typeof btoa) {
|
||
var sourceMapping = toComment(cssMapping),
|
||
sourceURLs = cssMapping.sources.map(function (source) {
|
||
return "/*# sourceURL=" + cssMapping.sourceRoot + source + " */";
|
||
});
|
||
return [content].concat(sourceURLs).concat([sourceMapping]).join("\n");
|
||
}
|
||
return [content].join("\n");
|
||
}
|
||
function toComment(sourceMap) {
|
||
return (
|
||
"/*# " +
|
||
("sourceMappingURL=data:application/json;charset=utf-8;base64," +
|
||
btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap))))) +
|
||
" */"
|
||
);
|
||
}
|
||
module.exports = function (useSourceMap) {
|
||
var list = [];
|
||
return (
|
||
(list.toString = function () {
|
||
return this.map(function (item) {
|
||
var content = cssWithMappingToString(item, useSourceMap);
|
||
return item[2]
|
||
? "@media " + item[2] + "{" + content + "}"
|
||
: content;
|
||
}).join("");
|
||
}),
|
||
(list.i = function (modules, mediaQuery) {
|
||
"string" == typeof modules && (modules = [[null, modules, ""]]);
|
||
for (var alreadyImportedModules = {}, i = 0; i < this.length; i++) {
|
||
var id = this[i][0];
|
||
"number" == typeof id && (alreadyImportedModules[id] = !0);
|
||
}
|
||
for (i = 0; i < modules.length; i++) {
|
||
var item = modules[i];
|
||
("number" == typeof item[0] && alreadyImportedModules[item[0]]) ||
|
||
(mediaQuery && !item[2]
|
||
? (item[2] = mediaQuery)
|
||
: mediaQuery &&
|
||
(item[2] = "(" + item[2] + ") and (" + mediaQuery + ")"),
|
||
list.push(item));
|
||
}
|
||
}),
|
||
list
|
||
);
|
||
};
|
||
},
|
||
function (module, exports, __webpack_require__) {
|
||
function addStylesToDom(styles, options) {
|
||
for (var i = 0; i < styles.length; i++) {
|
||
var item = styles[i],
|
||
domStyle = stylesInDom[item.id];
|
||
if (domStyle) {
|
||
domStyle.refs++;
|
||
for (j = 0; j < domStyle.parts.length; j++)
|
||
domStyle.parts[j](item.parts[j]);
|
||
for (; j < item.parts.length; j++)
|
||
domStyle.parts.push(addStyle(item.parts[j], options));
|
||
} else {
|
||
for (var parts = [], j = 0; j < item.parts.length; j++)
|
||
parts.push(addStyle(item.parts[j], options));
|
||
stylesInDom[item.id] = {
|
||
id: item.id,
|
||
refs: 1,
|
||
parts: parts,
|
||
};
|
||
}
|
||
}
|
||
}
|
||
function listToStyles(list, options) {
|
||
for (var styles = [], newStyles = {}, i = 0; i < list.length; i++) {
|
||
var item = list[i],
|
||
id = options.base ? item[0] + options.base : item[0],
|
||
part = {
|
||
css: item[1],
|
||
media: item[2],
|
||
sourceMap: item[3],
|
||
};
|
||
newStyles[id]
|
||
? newStyles[id].parts.push(part)
|
||
: styles.push(
|
||
(newStyles[id] = {
|
||
id: id,
|
||
parts: [part],
|
||
})
|
||
);
|
||
}
|
||
return styles;
|
||
}
|
||
function insertStyleElement(options, style) {
|
||
var target = getElement(options.insertInto);
|
||
if (!target)
|
||
throw new Error(
|
||
"Couldn't find a style target. This probably means that the value for the 'insertInto' parameter is invalid."
|
||
);
|
||
var lastStyleElementInsertedAtTop =
|
||
stylesInsertedAtTop[stylesInsertedAtTop.length - 1];
|
||
if ("top" === options.insertAt)
|
||
lastStyleElementInsertedAtTop
|
||
? lastStyleElementInsertedAtTop.nextSibling
|
||
? target.insertBefore(
|
||
style,
|
||
lastStyleElementInsertedAtTop.nextSibling
|
||
)
|
||
: target.appendChild(style)
|
||
: target.insertBefore(style, target.firstChild),
|
||
stylesInsertedAtTop.push(style);
|
||
else if ("bottom" === options.insertAt) target.appendChild(style);
|
||
else {
|
||
if ("object" != typeof options.insertAt || !options.insertAt.before)
|
||
throw new Error(
|
||
"[Style Loader]\n\n Invalid value for parameter 'insertAt' ('options.insertAt') found.\n Must be 'top', 'bottom', or Object.\n (https://github.com/webpack-contrib/style-loader#insertat)\n"
|
||
);
|
||
var nextSibling = getElement(
|
||
options.insertInto + " " + options.insertAt.before
|
||
);
|
||
target.insertBefore(style, nextSibling);
|
||
}
|
||
}
|
||
function removeStyleElement(style) {
|
||
if (null === style.parentNode) return !1;
|
||
style.parentNode.removeChild(style);
|
||
var idx = stylesInsertedAtTop.indexOf(style);
|
||
idx >= 0 && stylesInsertedAtTop.splice(idx, 1);
|
||
}
|
||
function createStyleElement(options) {
|
||
var style = document.createElement("style");
|
||
return (
|
||
(options.attrs.type = "text/css"),
|
||
addAttrs(style, options.attrs),
|
||
insertStyleElement(options, style),
|
||
style
|
||
);
|
||
}
|
||
function createLinkElement(options) {
|
||
var link = document.createElement("link");
|
||
return (
|
||
(options.attrs.type = "text/css"),
|
||
(options.attrs.rel = "stylesheet"),
|
||
addAttrs(link, options.attrs),
|
||
insertStyleElement(options, link),
|
||
link
|
||
);
|
||
}
|
||
function addAttrs(el, attrs) {
|
||
Object.keys(attrs).forEach(function (key) {
|
||
el.setAttribute(key, attrs[key]);
|
||
});
|
||
}
|
||
function addStyle(obj, options) {
|
||
var style, update, remove, result;
|
||
if (options.transform && obj.css) {
|
||
if (!(result = options.transform(obj.css))) return function () {};
|
||
obj.css = result;
|
||
}
|
||
if (options.singleton) {
|
||
var styleIndex = singletonCounter++;
|
||
(style = singleton || (singleton = createStyleElement(options))),
|
||
(update = applyToSingletonTag.bind(null, style, styleIndex, !1)),
|
||
(remove = applyToSingletonTag.bind(null, style, styleIndex, !0));
|
||
} else
|
||
obj.sourceMap &&
|
||
"function" == typeof URL &&
|
||
"function" == typeof URL.createObjectURL &&
|
||
"function" == typeof URL.revokeObjectURL &&
|
||
"function" == typeof Blob &&
|
||
"function" == typeof btoa
|
||
? ((style = createLinkElement(options)),
|
||
(update = updateLink.bind(null, style, options)),
|
||
(remove = function () {
|
||
removeStyleElement(style),
|
||
style.href && URL.revokeObjectURL(style.href);
|
||
}))
|
||
: ((style = createStyleElement(options)),
|
||
(update = applyToTag.bind(null, style)),
|
||
(remove = function () {
|
||
removeStyleElement(style);
|
||
}));
|
||
return (
|
||
update(obj),
|
||
function (newObj) {
|
||
if (newObj) {
|
||
if (
|
||
newObj.css === obj.css &&
|
||
newObj.media === obj.media &&
|
||
newObj.sourceMap === obj.sourceMap
|
||
)
|
||
return;
|
||
update((obj = newObj));
|
||
} else remove();
|
||
}
|
||
);
|
||
}
|
||
function applyToSingletonTag(style, index, remove, obj) {
|
||
var css = remove ? "" : obj.css;
|
||
if (style.styleSheet) style.styleSheet.cssText = replaceText(index, css);
|
||
else {
|
||
var cssNode = document.createTextNode(css),
|
||
childNodes = style.childNodes;
|
||
childNodes[index] && style.removeChild(childNodes[index]),
|
||
childNodes.length
|
||
? style.insertBefore(cssNode, childNodes[index])
|
||
: style.appendChild(cssNode);
|
||
}
|
||
}
|
||
function applyToTag(style, obj) {
|
||
var css = obj.css,
|
||
media = obj.media;
|
||
if ((media && style.setAttribute("media", media), style.styleSheet))
|
||
style.styleSheet.cssText = css;
|
||
else {
|
||
for (; style.firstChild; ) style.removeChild(style.firstChild);
|
||
style.appendChild(document.createTextNode(css));
|
||
}
|
||
}
|
||
function updateLink(link, options, obj) {
|
||
var css = obj.css,
|
||
sourceMap = obj.sourceMap,
|
||
autoFixUrls = void 0 === options.convertToAbsoluteUrls && sourceMap;
|
||
(options.convertToAbsoluteUrls || autoFixUrls) && (css = fixUrls(css)),
|
||
sourceMap &&
|
||
(css +=
|
||
"\n/*# sourceMappingURL=data:application/json;base64," +
|
||
btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) +
|
||
" */");
|
||
var blob = new Blob([css], {
|
||
type: "text/css",
|
||
}),
|
||
oldSrc = link.href;
|
||
(link.href = URL.createObjectURL(blob)),
|
||
oldSrc && URL.revokeObjectURL(oldSrc);
|
||
}
|
||
var stylesInDom = {},
|
||
isOldIE = (function (fn) {
|
||
var memo;
|
||
return function () {
|
||
return void 0 === memo && (memo = fn.apply(this, arguments)), memo;
|
||
};
|
||
})(function () {
|
||
return window && document && document.all && !window.atob;
|
||
}),
|
||
getElement = (function (fn) {
|
||
var memo = {};
|
||
return function (selector) {
|
||
if (void 0 === memo[selector]) {
|
||
var styleTarget = fn.call(this, selector);
|
||
if (styleTarget instanceof window.HTMLIFrameElement)
|
||
try {
|
||
styleTarget = styleTarget.contentDocument.head;
|
||
} catch (e) {
|
||
styleTarget = null;
|
||
}
|
||
memo[selector] = styleTarget;
|
||
}
|
||
return memo[selector];
|
||
};
|
||
})(function (target) {
|
||
return document.querySelector(target);
|
||
}),
|
||
singleton = null,
|
||
singletonCounter = 0,
|
||
stylesInsertedAtTop = [],
|
||
fixUrls = __webpack_require__(8);
|
||
module.exports = function (list, options) {
|
||
if ("undefined" != typeof DEBUG && DEBUG && "object" != typeof document)
|
||
throw new Error(
|
||
"The style-loader cannot be used in a non-browser environment"
|
||
);
|
||
((options = options || {}).attrs =
|
||
"object" == typeof options.attrs ? options.attrs : {}),
|
||
options.singleton || (options.singleton = isOldIE()),
|
||
options.insertInto || (options.insertInto = "head"),
|
||
options.insertAt || (options.insertAt = "bottom");
|
||
var styles = listToStyles(list, options);
|
||
return (
|
||
addStylesToDom(styles, options),
|
||
function (newList) {
|
||
for (var mayRemove = [], i = 0; i < styles.length; i++) {
|
||
var item = styles[i];
|
||
(domStyle = stylesInDom[item.id]).refs--, mayRemove.push(domStyle);
|
||
}
|
||
newList && addStylesToDom(listToStyles(newList, options), options);
|
||
for (i = 0; i < mayRemove.length; i++) {
|
||
var domStyle = mayRemove[i];
|
||
if (0 === domStyle.refs) {
|
||
for (var j = 0; j < domStyle.parts.length; j++)
|
||
domStyle.parts[j]();
|
||
delete stylesInDom[domStyle.id];
|
||
}
|
||
}
|
||
}
|
||
);
|
||
};
|
||
var replaceText = (function () {
|
||
var textStore = [];
|
||
return function (index, replacement) {
|
||
return (
|
||
(textStore[index] = replacement), textStore.filter(Boolean).join("\n")
|
||
);
|
||
};
|
||
})();
|
||
},
|
||
function (module, exports) {
|
||
module.exports = function (css) {
|
||
var location = "undefined" != typeof window && window.location;
|
||
if (!location) throw new Error("fixUrls requires window.location");
|
||
if (!css || "string" != typeof css) return css;
|
||
var baseUrl = location.protocol + "//" + location.host,
|
||
currentDir = baseUrl + location.pathname.replace(/\/[^\/]*$/, "/");
|
||
return css.replace(
|
||
/url\s*\(((?:[^)(]|\((?:[^)(]+|\([^)(]*\))*\))*)\)/gi,
|
||
function (fullMatch, origUrl) {
|
||
var unquotedOrigUrl = origUrl
|
||
.trim()
|
||
.replace(/^"(.*)"$/, function (o, $1) {
|
||
return $1;
|
||
})
|
||
.replace(/^'(.*)'$/, function (o, $1) {
|
||
return $1;
|
||
});
|
||
if (
|
||
/^(#|data:|http:\/\/|https:\/\/|file:\/\/\/)/i.test(unquotedOrigUrl)
|
||
)
|
||
return fullMatch;
|
||
var newUrl;
|
||
return (
|
||
(newUrl =
|
||
0 === unquotedOrigUrl.indexOf("//")
|
||
? unquotedOrigUrl
|
||
: 0 === unquotedOrigUrl.indexOf("/")
|
||
? baseUrl + unquotedOrigUrl
|
||
: currentDir + unquotedOrigUrl.replace(/^\.\//, "")),
|
||
"url(" + JSON.stringify(newUrl) + ")"
|
||
);
|
||
}
|
||
);
|
||
};
|
||
},
|
||
function (module, exports, __webpack_require__) {
|
||
"use strict";
|
||
var __WEBPACK_AMD_DEFINE_FACTORY__,
|
||
__WEBPACK_AMD_DEFINE_ARRAY__,
|
||
__WEBPACK_AMD_DEFINE_RESULT__;
|
||
"function" == typeof Symbol && Symbol.iterator;
|
||
!(function (factory) {
|
||
(__WEBPACK_AMD_DEFINE_ARRAY__ = [
|
||
__webpack_require__(0),
|
||
__webpack_require__(1),
|
||
]),
|
||
void 0 !==
|
||
(__WEBPACK_AMD_DEFINE_RESULT__ =
|
||
"function" == typeof (__WEBPACK_AMD_DEFINE_FACTORY__ = factory)
|
||
? __WEBPACK_AMD_DEFINE_FACTORY__.apply(
|
||
exports,
|
||
__WEBPACK_AMD_DEFINE_ARRAY__
|
||
)
|
||
: __WEBPACK_AMD_DEFINE_FACTORY__) &&
|
||
(module.exports = __WEBPACK_AMD_DEFINE_RESULT__);
|
||
})(function ($, Inputmask) {
|
||
function isLeapYear(year) {
|
||
return isNaN(year) || 29 === new Date(year, 2, 0).getDate();
|
||
}
|
||
return (
|
||
Inputmask.extendAliases({
|
||
"dd/mm/yyyy": {
|
||
mask: "1/2/y",
|
||
placeholder: "dd/mm/yyyy",
|
||
regex: {
|
||
val1pre: new RegExp("[0-3]"),
|
||
val1: new RegExp("0[1-9]|[12][0-9]|3[01]"),
|
||
val2pre: function (separator) {
|
||
var escapedSeparator = Inputmask.escapeRegex.call(
|
||
this,
|
||
separator
|
||
);
|
||
return new RegExp(
|
||
"((0[1-9]|[12][0-9]|3[01])" + escapedSeparator + "[01])"
|
||
);
|
||
},
|
||
val2: function (separator) {
|
||
var escapedSeparator = Inputmask.escapeRegex.call(
|
||
this,
|
||
separator
|
||
);
|
||
return new RegExp(
|
||
"((0[1-9]|[12][0-9])" +
|
||
escapedSeparator +
|
||
"(0[1-9]|1[012]))|(30" +
|
||
escapedSeparator +
|
||
"(0[13-9]|1[012]))|(31" +
|
||
escapedSeparator +
|
||
"(0[13578]|1[02]))"
|
||
);
|
||
},
|
||
},
|
||
leapday: "29/02/",
|
||
separator: "/",
|
||
yearrange: {
|
||
minyear: 1900,
|
||
maxyear: 2099,
|
||
},
|
||
isInYearRange: function (chrs, minyear, maxyear) {
|
||
if (isNaN(chrs)) return !1;
|
||
var enteredyear = parseInt(
|
||
chrs.concat(minyear.toString().slice(chrs.length))
|
||
),
|
||
enteredyear2 = parseInt(
|
||
chrs.concat(maxyear.toString().slice(chrs.length))
|
||
);
|
||
return (
|
||
(!isNaN(enteredyear) &&
|
||
minyear <= enteredyear &&
|
||
enteredyear <= maxyear) ||
|
||
(!isNaN(enteredyear2) &&
|
||
minyear <= enteredyear2 &&
|
||
enteredyear2 <= maxyear)
|
||
);
|
||
},
|
||
determinebaseyear: function (minyear, maxyear, hint) {
|
||
var currentyear = new Date().getFullYear();
|
||
if (minyear > currentyear) return minyear;
|
||
if (maxyear < currentyear) {
|
||
for (
|
||
var maxYearPrefix = maxyear.toString().slice(0, 2),
|
||
maxYearPostfix = maxyear.toString().slice(2, 4);
|
||
maxyear < maxYearPrefix + hint;
|
||
|
||
)
|
||
maxYearPrefix--;
|
||
var maxxYear = maxYearPrefix + maxYearPostfix;
|
||
return minyear > maxxYear ? minyear : maxxYear;
|
||
}
|
||
if (minyear <= currentyear && currentyear <= maxyear) {
|
||
for (
|
||
var currentYearPrefix = currentyear.toString().slice(0, 2);
|
||
maxyear < currentYearPrefix + hint;
|
||
|
||
)
|
||
currentYearPrefix--;
|
||
var currentYearAndHint = currentYearPrefix + hint;
|
||
return currentYearAndHint < minyear
|
||
? minyear
|
||
: currentYearAndHint;
|
||
}
|
||
return currentyear;
|
||
},
|
||
onKeyDown: function (e, buffer, caretPos, opts) {
|
||
var $input = $(this);
|
||
if (e.ctrlKey && e.keyCode === Inputmask.keyCode.RIGHT) {
|
||
var today = new Date();
|
||
$input.val(
|
||
today.getDate().toString() +
|
||
(today.getMonth() + 1).toString() +
|
||
today.getFullYear().toString()
|
||
),
|
||
$input.trigger("setvalue");
|
||
}
|
||
},
|
||
getFrontValue: function (mask, buffer, opts) {
|
||
for (
|
||
var start = 0, length = 0, i = 0;
|
||
i < mask.length && "2" !== mask.charAt(i);
|
||
i++
|
||
) {
|
||
var definition = opts.definitions[mask.charAt(i)];
|
||
definition
|
||
? ((start += length), (length = definition.cardinality))
|
||
: length++;
|
||
}
|
||
return buffer.join("").substr(start, length);
|
||
},
|
||
postValidation: function (buffer, currentResult, opts) {
|
||
var dayMonthValue,
|
||
year,
|
||
bufferStr = buffer.join("");
|
||
return (
|
||
0 === opts.mask.indexOf("y")
|
||
? ((year = bufferStr.substr(0, 4)),
|
||
(dayMonthValue = bufferStr.substring(4, 10)))
|
||
: ((year = bufferStr.substring(6, 10)),
|
||
(dayMonthValue = bufferStr.substr(0, 6))),
|
||
currentResult &&
|
||
(dayMonthValue !== opts.leapday || isLeapYear(year))
|
||
);
|
||
},
|
||
definitions: {
|
||
1: {
|
||
validator: function (chrs, maskset, pos, strict, opts) {
|
||
var isValid = opts.regex.val1.test(chrs);
|
||
return strict ||
|
||
isValid ||
|
||
(chrs.charAt(1) !== opts.separator &&
|
||
-1 === "-./".indexOf(chrs.charAt(1))) ||
|
||
!(isValid = opts.regex.val1.test("0" + chrs.charAt(0)))
|
||
? isValid
|
||
: ((maskset.buffer[pos - 1] = "0"),
|
||
{
|
||
refreshFromBuffer: {
|
||
start: pos - 1,
|
||
end: pos,
|
||
},
|
||
pos: pos,
|
||
c: chrs.charAt(0),
|
||
});
|
||
},
|
||
cardinality: 2,
|
||
prevalidator: [
|
||
{
|
||
validator: function (chrs, maskset, pos, strict, opts) {
|
||
var pchrs = chrs;
|
||
isNaN(maskset.buffer[pos + 1]) ||
|
||
(pchrs += maskset.buffer[pos + 1]);
|
||
var isValid =
|
||
1 === pchrs.length
|
||
? opts.regex.val1pre.test(pchrs)
|
||
: opts.regex.val1.test(pchrs);
|
||
if (
|
||
(isValid &&
|
||
maskset.validPositions[pos] &&
|
||
(opts.regex
|
||
.val2(opts.separator)
|
||
.test(chrs + maskset.validPositions[pos].input) ||
|
||
(maskset.validPositions[pos].input =
|
||
"0" === chrs ? "1" : "0")),
|
||
!strict && !isValid)
|
||
) {
|
||
if ((isValid = opts.regex.val1.test(chrs + "0")))
|
||
return (
|
||
(maskset.buffer[pos] = chrs),
|
||
(maskset.buffer[++pos] = "0"),
|
||
{
|
||
pos: pos,
|
||
c: "0",
|
||
}
|
||
);
|
||
if ((isValid = opts.regex.val1.test("0" + chrs)))
|
||
return (
|
||
(maskset.buffer[pos] = "0"),
|
||
pos++,
|
||
{
|
||
pos: pos,
|
||
}
|
||
);
|
||
}
|
||
return isValid;
|
||
},
|
||
cardinality: 1,
|
||
},
|
||
],
|
||
},
|
||
2: {
|
||
validator: function (chrs, maskset, pos, strict, opts) {
|
||
var frontValue = opts.getFrontValue(
|
||
maskset.mask,
|
||
maskset.buffer,
|
||
opts
|
||
);
|
||
-1 !== frontValue.indexOf(opts.placeholder[0]) &&
|
||
(frontValue = "01" + opts.separator);
|
||
var isValid = opts.regex
|
||
.val2(opts.separator)
|
||
.test(frontValue + chrs);
|
||
return strict ||
|
||
isValid ||
|
||
(chrs.charAt(1) !== opts.separator &&
|
||
-1 === "-./".indexOf(chrs.charAt(1))) ||
|
||
!(isValid = opts.regex
|
||
.val2(opts.separator)
|
||
.test(frontValue + "0" + chrs.charAt(0)))
|
||
? isValid
|
||
: ((maskset.buffer[pos - 1] = "0"),
|
||
{
|
||
refreshFromBuffer: {
|
||
start: pos - 1,
|
||
end: pos,
|
||
},
|
||
pos: pos,
|
||
c: chrs.charAt(0),
|
||
});
|
||
},
|
||
cardinality: 2,
|
||
prevalidator: [
|
||
{
|
||
validator: function (chrs, maskset, pos, strict, opts) {
|
||
isNaN(maskset.buffer[pos + 1]) ||
|
||
(chrs += maskset.buffer[pos + 1]);
|
||
var frontValue = opts.getFrontValue(
|
||
maskset.mask,
|
||
maskset.buffer,
|
||
opts
|
||
);
|
||
-1 !== frontValue.indexOf(opts.placeholder[0]) &&
|
||
(frontValue = "01" + opts.separator);
|
||
var isValid =
|
||
1 === chrs.length
|
||
? opts.regex
|
||
.val2pre(opts.separator)
|
||
.test(frontValue + chrs)
|
||
: opts.regex
|
||
.val2(opts.separator)
|
||
.test(frontValue + chrs);
|
||
return (
|
||
isValid &&
|
||
maskset.validPositions[pos] &&
|
||
(opts.regex
|
||
.val2(opts.separator)
|
||
.test(chrs + maskset.validPositions[pos].input) ||
|
||
(maskset.validPositions[pos].input =
|
||
"0" === chrs ? "1" : "0")),
|
||
strict ||
|
||
isValid ||
|
||
!(isValid = opts.regex
|
||
.val2(opts.separator)
|
||
.test(frontValue + "0" + chrs))
|
||
? isValid
|
||
: ((maskset.buffer[pos] = "0"),
|
||
pos++,
|
||
{
|
||
pos: pos,
|
||
})
|
||
);
|
||
},
|
||
cardinality: 1,
|
||
},
|
||
],
|
||
},
|
||
y: {
|
||
validator: function (chrs, maskset, pos, strict, opts) {
|
||
return opts.isInYearRange(
|
||
chrs,
|
||
opts.yearrange.minyear,
|
||
opts.yearrange.maxyear
|
||
);
|
||
},
|
||
cardinality: 4,
|
||
prevalidator: [
|
||
{
|
||
validator: function (chrs, maskset, pos, strict, opts) {
|
||
var isValid = opts.isInYearRange(
|
||
chrs,
|
||
opts.yearrange.minyear,
|
||
opts.yearrange.maxyear
|
||
);
|
||
if (!strict && !isValid) {
|
||
var yearPrefix = opts
|
||
.determinebaseyear(
|
||
opts.yearrange.minyear,
|
||
opts.yearrange.maxyear,
|
||
chrs + "0"
|
||
)
|
||
.toString()
|
||
.slice(0, 1);
|
||
if (
|
||
(isValid = opts.isInYearRange(
|
||
yearPrefix + chrs,
|
||
opts.yearrange.minyear,
|
||
opts.yearrange.maxyear
|
||
))
|
||
)
|
||
return (
|
||
(maskset.buffer[pos++] = yearPrefix.charAt(0)),
|
||
{
|
||
pos: pos,
|
||
}
|
||
);
|
||
if (
|
||
((yearPrefix = opts
|
||
.determinebaseyear(
|
||
opts.yearrange.minyear,
|
||
opts.yearrange.maxyear,
|
||
chrs + "0"
|
||
)
|
||
.toString()
|
||
.slice(0, 2)),
|
||
(isValid = opts.isInYearRange(
|
||
yearPrefix + chrs,
|
||
opts.yearrange.minyear,
|
||
opts.yearrange.maxyear
|
||
)))
|
||
)
|
||
return (
|
||
(maskset.buffer[pos++] = yearPrefix.charAt(0)),
|
||
(maskset.buffer[pos++] = yearPrefix.charAt(1)),
|
||
{
|
||
pos: pos,
|
||
}
|
||
);
|
||
}
|
||
return isValid;
|
||
},
|
||
cardinality: 1,
|
||
},
|
||
{
|
||
validator: function (chrs, maskset, pos, strict, opts) {
|
||
var isValid = opts.isInYearRange(
|
||
chrs,
|
||
opts.yearrange.minyear,
|
||
opts.yearrange.maxyear
|
||
);
|
||
if (!strict && !isValid) {
|
||
var yearPrefix = opts
|
||
.determinebaseyear(
|
||
opts.yearrange.minyear,
|
||
opts.yearrange.maxyear,
|
||
chrs
|
||
)
|
||
.toString()
|
||
.slice(0, 2);
|
||
if (
|
||
(isValid = opts.isInYearRange(
|
||
chrs[0] + yearPrefix[1] + chrs[1],
|
||
opts.yearrange.minyear,
|
||
opts.yearrange.maxyear
|
||
))
|
||
)
|
||
return (
|
||
(maskset.buffer[pos++] = yearPrefix.charAt(1)),
|
||
{
|
||
pos: pos,
|
||
}
|
||
);
|
||
if (
|
||
((yearPrefix = opts
|
||
.determinebaseyear(
|
||
opts.yearrange.minyear,
|
||
opts.yearrange.maxyear,
|
||
chrs
|
||
)
|
||
.toString()
|
||
.slice(0, 2)),
|
||
(isValid = opts.isInYearRange(
|
||
yearPrefix + chrs,
|
||
opts.yearrange.minyear,
|
||
opts.yearrange.maxyear
|
||
)))
|
||
)
|
||
return (
|
||
(maskset.buffer[pos - 1] = yearPrefix.charAt(0)),
|
||
(maskset.buffer[pos++] = yearPrefix.charAt(1)),
|
||
(maskset.buffer[pos++] = chrs.charAt(0)),
|
||
{
|
||
refreshFromBuffer: {
|
||
start: pos - 3,
|
||
end: pos,
|
||
},
|
||
pos: pos,
|
||
}
|
||
);
|
||
}
|
||
return isValid;
|
||
},
|
||
cardinality: 2,
|
||
},
|
||
{
|
||
validator: function (chrs, maskset, pos, strict, opts) {
|
||
return opts.isInYearRange(
|
||
chrs,
|
||
opts.yearrange.minyear,
|
||
opts.yearrange.maxyear
|
||
);
|
||
},
|
||
cardinality: 3,
|
||
},
|
||
],
|
||
},
|
||
},
|
||
insertMode: !1,
|
||
autoUnmask: !1,
|
||
},
|
||
"mm/dd/yyyy": {
|
||
placeholder: "mm/dd/yyyy",
|
||
alias: "dd/mm/yyyy",
|
||
regex: {
|
||
val2pre: function (separator) {
|
||
var escapedSeparator = Inputmask.escapeRegex.call(
|
||
this,
|
||
separator
|
||
);
|
||
return new RegExp(
|
||
"((0[13-9]|1[012])" +
|
||
escapedSeparator +
|
||
"[0-3])|(02" +
|
||
escapedSeparator +
|
||
"[0-2])"
|
||
);
|
||
},
|
||
val2: function (separator) {
|
||
var escapedSeparator = Inputmask.escapeRegex.call(
|
||
this,
|
||
separator
|
||
);
|
||
return new RegExp(
|
||
"((0[1-9]|1[012])" +
|
||
escapedSeparator +
|
||
"(0[1-9]|[12][0-9]))|((0[13-9]|1[012])" +
|
||
escapedSeparator +
|
||
"30)|((0[13578]|1[02])" +
|
||
escapedSeparator +
|
||
"31)"
|
||
);
|
||
},
|
||
val1pre: new RegExp("[01]"),
|
||
val1: new RegExp("0[1-9]|1[012]"),
|
||
},
|
||
leapday: "02/29/",
|
||
onKeyDown: function (e, buffer, caretPos, opts) {
|
||
var $input = $(this);
|
||
if (e.ctrlKey && e.keyCode === Inputmask.keyCode.RIGHT) {
|
||
var today = new Date();
|
||
$input.val(
|
||
(today.getMonth() + 1).toString() +
|
||
today.getDate().toString() +
|
||
today.getFullYear().toString()
|
||
),
|
||
$input.trigger("setvalue");
|
||
}
|
||
},
|
||
},
|
||
"yyyy/mm/dd": {
|
||
mask: "y/1/2",
|
||
placeholder: "yyyy/mm/dd",
|
||
alias: "mm/dd/yyyy",
|
||
leapday: "/02/29",
|
||
onKeyDown: function (e, buffer, caretPos, opts) {
|
||
var $input = $(this);
|
||
if (e.ctrlKey && e.keyCode === Inputmask.keyCode.RIGHT) {
|
||
var today = new Date();
|
||
$input.val(
|
||
today.getFullYear().toString() +
|
||
(today.getMonth() + 1).toString() +
|
||
today.getDate().toString()
|
||
),
|
||
$input.trigger("setvalue");
|
||
}
|
||
},
|
||
},
|
||
"dd.mm.yyyy": {
|
||
mask: "1.2.y",
|
||
placeholder: "dd.mm.yyyy",
|
||
leapday: "29.02.",
|
||
separator: ".",
|
||
alias: "dd/mm/yyyy",
|
||
},
|
||
"dd-mm-yyyy": {
|
||
mask: "1-2-y",
|
||
placeholder: "dd-mm-yyyy",
|
||
leapday: "29-02-",
|
||
separator: "-",
|
||
alias: "dd/mm/yyyy",
|
||
},
|
||
"mm.dd.yyyy": {
|
||
mask: "1.2.y",
|
||
placeholder: "mm.dd.yyyy",
|
||
leapday: "02.29.",
|
||
separator: ".",
|
||
alias: "mm/dd/yyyy",
|
||
},
|
||
"mm-dd-yyyy": {
|
||
mask: "1-2-y",
|
||
placeholder: "mm-dd-yyyy",
|
||
leapday: "02-29-",
|
||
separator: "-",
|
||
alias: "mm/dd/yyyy",
|
||
},
|
||
"yyyy.mm.dd": {
|
||
mask: "y.1.2",
|
||
placeholder: "yyyy.mm.dd",
|
||
leapday: ".02.29",
|
||
separator: ".",
|
||
alias: "yyyy/mm/dd",
|
||
},
|
||
"yyyy-mm-dd": {
|
||
mask: "y-1-2",
|
||
placeholder: "yyyy-mm-dd",
|
||
leapday: "-02-29",
|
||
separator: "-",
|
||
alias: "yyyy/mm/dd",
|
||
},
|
||
datetime: {
|
||
mask: "1/2/y h:s",
|
||
placeholder: "dd/mm/yyyy hh:mm",
|
||
alias: "dd/mm/yyyy",
|
||
regex: {
|
||
hrspre: new RegExp("[012]"),
|
||
hrs24: new RegExp("2[0-4]|1[3-9]"),
|
||
hrs: new RegExp("[01][0-9]|2[0-4]"),
|
||
ampm: new RegExp("^[a|p|A|P][m|M]"),
|
||
mspre: new RegExp("[0-5]"),
|
||
ms: new RegExp("[0-5][0-9]"),
|
||
},
|
||
timeseparator: ":",
|
||
hourFormat: "24",
|
||
definitions: {
|
||
h: {
|
||
validator: function (chrs, maskset, pos, strict, opts) {
|
||
if ("24" === opts.hourFormat && 24 === parseInt(chrs, 10))
|
||
return (
|
||
(maskset.buffer[pos - 1] = "0"),
|
||
(maskset.buffer[pos] = "0"),
|
||
{
|
||
refreshFromBuffer: {
|
||
start: pos - 1,
|
||
end: pos,
|
||
},
|
||
c: "0",
|
||
}
|
||
);
|
||
var isValid = opts.regex.hrs.test(chrs);
|
||
if (
|
||
!strict &&
|
||
!isValid &&
|
||
(chrs.charAt(1) === opts.timeseparator ||
|
||
-1 !== "-.:".indexOf(chrs.charAt(1))) &&
|
||
(isValid = opts.regex.hrs.test("0" + chrs.charAt(0)))
|
||
)
|
||
return (
|
||
(maskset.buffer[pos - 1] = "0"),
|
||
(maskset.buffer[pos] = chrs.charAt(0)),
|
||
pos++,
|
||
{
|
||
refreshFromBuffer: {
|
||
start: pos - 2,
|
||
end: pos,
|
||
},
|
||
pos: pos,
|
||
c: opts.timeseparator,
|
||
}
|
||
);
|
||
if (
|
||
isValid &&
|
||
"24" !== opts.hourFormat &&
|
||
opts.regex.hrs24.test(chrs)
|
||
) {
|
||
var tmp = parseInt(chrs, 10);
|
||
return (
|
||
24 === tmp
|
||
? ((maskset.buffer[pos + 5] = "a"),
|
||
(maskset.buffer[pos + 6] = "m"))
|
||
: ((maskset.buffer[pos + 5] = "p"),
|
||
(maskset.buffer[pos + 6] = "m")),
|
||
(tmp -= 12) < 10
|
||
? ((maskset.buffer[pos] = tmp.toString()),
|
||
(maskset.buffer[pos - 1] = "0"))
|
||
: ((maskset.buffer[pos] = tmp.toString().charAt(1)),
|
||
(maskset.buffer[pos - 1] = tmp.toString().charAt(0))),
|
||
{
|
||
refreshFromBuffer: {
|
||
start: pos - 1,
|
||
end: pos + 6,
|
||
},
|
||
c: maskset.buffer[pos],
|
||
}
|
||
);
|
||
}
|
||
return isValid;
|
||
},
|
||
cardinality: 2,
|
||
prevalidator: [
|
||
{
|
||
validator: function (chrs, maskset, pos, strict, opts) {
|
||
var isValid = opts.regex.hrspre.test(chrs);
|
||
return strict ||
|
||
isValid ||
|
||
!(isValid = opts.regex.hrs.test("0" + chrs))
|
||
? isValid
|
||
: ((maskset.buffer[pos] = "0"),
|
||
pos++,
|
||
{
|
||
pos: pos,
|
||
});
|
||
},
|
||
cardinality: 1,
|
||
},
|
||
],
|
||
},
|
||
s: {
|
||
validator: "[0-5][0-9]",
|
||
cardinality: 2,
|
||
prevalidator: [
|
||
{
|
||
validator: function (chrs, maskset, pos, strict, opts) {
|
||
var isValid = opts.regex.mspre.test(chrs);
|
||
return strict ||
|
||
isValid ||
|
||
!(isValid = opts.regex.ms.test("0" + chrs))
|
||
? isValid
|
||
: ((maskset.buffer[pos] = "0"),
|
||
pos++,
|
||
{
|
||
pos: pos,
|
||
});
|
||
},
|
||
cardinality: 1,
|
||
},
|
||
],
|
||
},
|
||
t: {
|
||
validator: function (chrs, maskset, pos, strict, opts) {
|
||
return opts.regex.ampm.test(chrs + "m");
|
||
},
|
||
casing: "lower",
|
||
cardinality: 1,
|
||
},
|
||
},
|
||
insertMode: !1,
|
||
autoUnmask: !1,
|
||
},
|
||
datetime12: {
|
||
mask: "1/2/y h:s t\\m",
|
||
placeholder: "dd/mm/yyyy hh:mm xm",
|
||
alias: "datetime",
|
||
hourFormat: "12",
|
||
},
|
||
"mm/dd/yyyy hh:mm xm": {
|
||
mask: "1/2/y h:s t\\m",
|
||
placeholder: "mm/dd/yyyy hh:mm xm",
|
||
alias: "datetime12",
|
||
regex: {
|
||
val2pre: function (separator) {
|
||
var escapedSeparator = Inputmask.escapeRegex.call(
|
||
this,
|
||
separator
|
||
);
|
||
return new RegExp(
|
||
"((0[13-9]|1[012])" +
|
||
escapedSeparator +
|
||
"[0-3])|(02" +
|
||
escapedSeparator +
|
||
"[0-2])"
|
||
);
|
||
},
|
||
val2: function (separator) {
|
||
var escapedSeparator = Inputmask.escapeRegex.call(
|
||
this,
|
||
separator
|
||
);
|
||
return new RegExp(
|
||
"((0[1-9]|1[012])" +
|
||
escapedSeparator +
|
||
"(0[1-9]|[12][0-9]))|((0[13-9]|1[012])" +
|
||
escapedSeparator +
|
||
"30)|((0[13578]|1[02])" +
|
||
escapedSeparator +
|
||
"31)"
|
||
);
|
||
},
|
||
val1pre: new RegExp("[01]"),
|
||
val1: new RegExp("0[1-9]|1[012]"),
|
||
},
|
||
leapday: "02/29/",
|
||
onKeyDown: function (e, buffer, caretPos, opts) {
|
||
var $input = $(this);
|
||
if (e.ctrlKey && e.keyCode === Inputmask.keyCode.RIGHT) {
|
||
var today = new Date();
|
||
$input.val(
|
||
(today.getMonth() + 1).toString() +
|
||
today.getDate().toString() +
|
||
today.getFullYear().toString()
|
||
),
|
||
$input.trigger("setvalue");
|
||
}
|
||
},
|
||
},
|
||
"hh:mm t": {
|
||
mask: "h:s t\\m",
|
||
placeholder: "hh:mm xm",
|
||
alias: "datetime",
|
||
hourFormat: "12",
|
||
},
|
||
"h:s t": {
|
||
mask: "h:s t\\m",
|
||
placeholder: "hh:mm xm",
|
||
alias: "datetime",
|
||
hourFormat: "12",
|
||
},
|
||
"hh:mm:ss": {
|
||
mask: "h:s:s",
|
||
placeholder: "hh:mm:ss",
|
||
alias: "datetime",
|
||
autoUnmask: !1,
|
||
},
|
||
"hh:mm": {
|
||
mask: "h:s",
|
||
placeholder: "hh:mm",
|
||
alias: "datetime",
|
||
autoUnmask: !1,
|
||
},
|
||
date: {
|
||
alias: "dd/mm/yyyy",
|
||
},
|
||
"mm/yyyy": {
|
||
mask: "1/y",
|
||
placeholder: "mm/yyyy",
|
||
leapday: "donotuse",
|
||
separator: "/",
|
||
alias: "mm/dd/yyyy",
|
||
},
|
||
shamsi: {
|
||
regex: {
|
||
val2pre: function (separator) {
|
||
var escapedSeparator = Inputmask.escapeRegex.call(
|
||
this,
|
||
separator
|
||
);
|
||
return new RegExp(
|
||
"((0[1-9]|1[012])" + escapedSeparator + "[0-3])"
|
||
);
|
||
},
|
||
val2: function (separator) {
|
||
var escapedSeparator = Inputmask.escapeRegex.call(
|
||
this,
|
||
separator
|
||
);
|
||
return new RegExp(
|
||
"((0[1-9]|1[012])" +
|
||
escapedSeparator +
|
||
"(0[1-9]|[12][0-9]))|((0[1-9]|1[012])" +
|
||
escapedSeparator +
|
||
"30)|((0[1-6])" +
|
||
escapedSeparator +
|
||
"31)"
|
||
);
|
||
},
|
||
val1pre: new RegExp("[01]"),
|
||
val1: new RegExp("0[1-9]|1[012]"),
|
||
},
|
||
yearrange: {
|
||
minyear: 1300,
|
||
maxyear: 1499,
|
||
},
|
||
mask: "y/1/2",
|
||
leapday: "/12/30",
|
||
placeholder: "yyyy/mm/dd",
|
||
alias: "mm/dd/yyyy",
|
||
clearIncomplete: !0,
|
||
},
|
||
"yyyy-mm-dd hh:mm:ss": {
|
||
mask: "y-1-2 h:s:s",
|
||
placeholder: "yyyy-mm-dd hh:mm:ss",
|
||
alias: "datetime",
|
||
separator: "-",
|
||
leapday: "-02-29",
|
||
regex: {
|
||
val2pre: function (separator) {
|
||
var escapedSeparator = Inputmask.escapeRegex.call(
|
||
this,
|
||
separator
|
||
);
|
||
return new RegExp(
|
||
"((0[13-9]|1[012])" +
|
||
escapedSeparator +
|
||
"[0-3])|(02" +
|
||
escapedSeparator +
|
||
"[0-2])"
|
||
);
|
||
},
|
||
val2: function (separator) {
|
||
var escapedSeparator = Inputmask.escapeRegex.call(
|
||
this,
|
||
separator
|
||
);
|
||
return new RegExp(
|
||
"((0[1-9]|1[012])" +
|
||
escapedSeparator +
|
||
"(0[1-9]|[12][0-9]))|((0[13-9]|1[012])" +
|
||
escapedSeparator +
|
||
"30)|((0[13578]|1[02])" +
|
||
escapedSeparator +
|
||
"31)"
|
||
);
|
||
},
|
||
val1pre: new RegExp("[01]"),
|
||
val1: new RegExp("0[1-9]|1[012]"),
|
||
},
|
||
onKeyDown: function (e, buffer, caretPos, opts) {},
|
||
},
|
||
}),
|
||
Inputmask
|
||
);
|
||
});
|
||
},
|
||
function (module, exports, __webpack_require__) {
|
||
"use strict";
|
||
var __WEBPACK_AMD_DEFINE_RESULT__;
|
||
"function" == typeof Symbol && Symbol.iterator;
|
||
void 0 !==
|
||
(__WEBPACK_AMD_DEFINE_RESULT__ = function () {
|
||
return window;
|
||
}.call(exports, __webpack_require__, exports, module)) &&
|
||
(module.exports = __WEBPACK_AMD_DEFINE_RESULT__);
|
||
},
|
||
function (module, exports, __webpack_require__) {
|
||
"use strict";
|
||
var __WEBPACK_AMD_DEFINE_RESULT__;
|
||
"function" == typeof Symbol && Symbol.iterator;
|
||
void 0 !==
|
||
(__WEBPACK_AMD_DEFINE_RESULT__ = function () {
|
||
return document;
|
||
}.call(exports, __webpack_require__, exports, module)) &&
|
||
(module.exports = __WEBPACK_AMD_DEFINE_RESULT__);
|
||
},
|
||
function (module, exports, __webpack_require__) {
|
||
"use strict";
|
||
var __WEBPACK_AMD_DEFINE_FACTORY__,
|
||
__WEBPACK_AMD_DEFINE_ARRAY__,
|
||
__WEBPACK_AMD_DEFINE_RESULT__;
|
||
"function" == typeof Symbol && Symbol.iterator;
|
||
!(function (factory) {
|
||
(__WEBPACK_AMD_DEFINE_ARRAY__ = [
|
||
__webpack_require__(0),
|
||
__webpack_require__(1),
|
||
]),
|
||
void 0 !==
|
||
(__WEBPACK_AMD_DEFINE_RESULT__ =
|
||
"function" == typeof (__WEBPACK_AMD_DEFINE_FACTORY__ = factory)
|
||
? __WEBPACK_AMD_DEFINE_FACTORY__.apply(
|
||
exports,
|
||
__WEBPACK_AMD_DEFINE_ARRAY__
|
||
)
|
||
: __WEBPACK_AMD_DEFINE_FACTORY__) &&
|
||
(module.exports = __WEBPACK_AMD_DEFINE_RESULT__);
|
||
})(function ($, Inputmask) {
|
||
return (
|
||
Inputmask.extendDefinitions({
|
||
A: {
|
||
validator: "[A-Za-zА-яЁёÀ-ÿµ]",
|
||
cardinality: 1,
|
||
casing: "upper",
|
||
},
|
||
"&": {
|
||
validator: "[0-9A-Za-zА-яЁёÀ-ÿµ]",
|
||
cardinality: 1,
|
||
casing: "upper",
|
||
},
|
||
"#": {
|
||
validator: "[0-9A-Fa-f]",
|
||
cardinality: 1,
|
||
casing: "upper",
|
||
},
|
||
}),
|
||
Inputmask.extendAliases({
|
||
url: {
|
||
definitions: {
|
||
i: {
|
||
validator: ".",
|
||
cardinality: 1,
|
||
},
|
||
},
|
||
mask: "(\\http://)|(\\http\\s://)|(ftp://)|(ftp\\s://)i{+}",
|
||
insertMode: !1,
|
||
autoUnmask: !1,
|
||
inputmode: "url",
|
||
},
|
||
ip: {
|
||
mask: "i[i[i]].i[i[i]].i[i[i]].i[i[i]]",
|
||
definitions: {
|
||
i: {
|
||
validator: function (chrs, maskset, pos, strict, opts) {
|
||
return (
|
||
pos - 1 > -1 && "." !== maskset.buffer[pos - 1]
|
||
? ((chrs = maskset.buffer[pos - 1] + chrs),
|
||
(chrs =
|
||
pos - 2 > -1 && "." !== maskset.buffer[pos - 2]
|
||
? maskset.buffer[pos - 2] + chrs
|
||
: "0" + chrs))
|
||
: (chrs = "00" + chrs),
|
||
new RegExp("25[0-5]|2[0-4][0-9]|[01][0-9][0-9]").test(chrs)
|
||
);
|
||
},
|
||
cardinality: 1,
|
||
},
|
||
},
|
||
onUnMask: function (maskedValue, unmaskedValue, opts) {
|
||
return maskedValue;
|
||
},
|
||
inputmode: "numeric",
|
||
},
|
||
email: {
|
||
mask: "*{1,64}[.*{1,64}][.*{1,64}][.*{1,63}]@-{1,63}.-{1,63}[.-{1,63}][.-{1,63}]",
|
||
greedy: !1,
|
||
onBeforePaste: function (pastedValue, opts) {
|
||
return (pastedValue = pastedValue.toLowerCase()).replace(
|
||
"mailto:",
|
||
""
|
||
);
|
||
},
|
||
definitions: {
|
||
"*": {
|
||
validator: "[0-9A-Za-z!#$%&'*+/=?^_`{|}~-]",
|
||
cardinality: 1,
|
||
casing: "lower",
|
||
},
|
||
"-": {
|
||
validator: "[0-9A-Za-z-]",
|
||
cardinality: 1,
|
||
casing: "lower",
|
||
},
|
||
},
|
||
onUnMask: function (maskedValue, unmaskedValue, opts) {
|
||
return maskedValue;
|
||
},
|
||
inputmode: "email",
|
||
},
|
||
mac: {
|
||
mask: "##:##:##:##:##:##",
|
||
},
|
||
vin: {
|
||
mask: "V{13}9{4}",
|
||
definitions: {
|
||
V: {
|
||
validator: "[A-HJ-NPR-Za-hj-npr-z\\d]",
|
||
cardinality: 1,
|
||
casing: "upper",
|
||
},
|
||
},
|
||
clearIncomplete: !0,
|
||
autoUnmask: !0,
|
||
},
|
||
}),
|
||
Inputmask
|
||
);
|
||
});
|
||
},
|
||
function (module, exports, __webpack_require__) {
|
||
"use strict";
|
||
var __WEBPACK_AMD_DEFINE_FACTORY__,
|
||
__WEBPACK_AMD_DEFINE_ARRAY__,
|
||
__WEBPACK_AMD_DEFINE_RESULT__;
|
||
"function" == typeof Symbol && Symbol.iterator;
|
||
!(function (factory) {
|
||
(__WEBPACK_AMD_DEFINE_ARRAY__ = [
|
||
__webpack_require__(0),
|
||
__webpack_require__(1),
|
||
]),
|
||
void 0 !==
|
||
(__WEBPACK_AMD_DEFINE_RESULT__ =
|
||
"function" == typeof (__WEBPACK_AMD_DEFINE_FACTORY__ = factory)
|
||
? __WEBPACK_AMD_DEFINE_FACTORY__.apply(
|
||
exports,
|
||
__WEBPACK_AMD_DEFINE_ARRAY__
|
||
)
|
||
: __WEBPACK_AMD_DEFINE_FACTORY__) &&
|
||
(module.exports = __WEBPACK_AMD_DEFINE_RESULT__);
|
||
})(function ($, Inputmask, undefined) {
|
||
function autoEscape(txt, opts) {
|
||
for (var escapedTxt = "", i = 0; i < txt.length; i++)
|
||
Inputmask.prototype.definitions[txt.charAt(i)] ||
|
||
opts.definitions[txt.charAt(i)] ||
|
||
opts.optionalmarker.start === txt.charAt(i) ||
|
||
opts.optionalmarker.end === txt.charAt(i) ||
|
||
opts.quantifiermarker.start === txt.charAt(i) ||
|
||
opts.quantifiermarker.end === txt.charAt(i) ||
|
||
opts.groupmarker.start === txt.charAt(i) ||
|
||
opts.groupmarker.end === txt.charAt(i) ||
|
||
opts.alternatormarker === txt.charAt(i)
|
||
? (escapedTxt += "\\" + txt.charAt(i))
|
||
: (escapedTxt += txt.charAt(i));
|
||
return escapedTxt;
|
||
}
|
||
return (
|
||
Inputmask.extendAliases({
|
||
numeric: {
|
||
mask: function (opts) {
|
||
if (
|
||
(0 !== opts.repeat &&
|
||
isNaN(opts.integerDigits) &&
|
||
(opts.integerDigits = opts.repeat),
|
||
(opts.repeat = 0),
|
||
opts.groupSeparator === opts.radixPoint &&
|
||
("." === opts.radixPoint
|
||
? (opts.groupSeparator = ",")
|
||
: "," === opts.radixPoint
|
||
? (opts.groupSeparator = ".")
|
||
: (opts.groupSeparator = "")),
|
||
" " === opts.groupSeparator &&
|
||
(opts.skipOptionalPartCharacter = undefined),
|
||
(opts.autoGroup = opts.autoGroup && "" !== opts.groupSeparator),
|
||
opts.autoGroup &&
|
||
("string" == typeof opts.groupSize &&
|
||
isFinite(opts.groupSize) &&
|
||
(opts.groupSize = parseInt(opts.groupSize)),
|
||
isFinite(opts.integerDigits)))
|
||
) {
|
||
var seps = Math.floor(opts.integerDigits / opts.groupSize),
|
||
mod = opts.integerDigits % opts.groupSize;
|
||
(opts.integerDigits =
|
||
parseInt(opts.integerDigits) + (0 === mod ? seps - 1 : seps)),
|
||
opts.integerDigits < 1 && (opts.integerDigits = "*");
|
||
}
|
||
opts.placeholder.length > 1 &&
|
||
(opts.placeholder = opts.placeholder.charAt(0)),
|
||
"radixFocus" === opts.positionCaretOnClick &&
|
||
"" === opts.placeholder &&
|
||
!1 === opts.integerOptional &&
|
||
(opts.positionCaretOnClick = "lvp"),
|
||
(opts.definitions[";"] = opts.definitions["~"]),
|
||
(opts.definitions[";"].definitionSymbol = "~"),
|
||
!0 === opts.numericInput &&
|
||
((opts.positionCaretOnClick =
|
||
"radixFocus" === opts.positionCaretOnClick
|
||
? "lvp"
|
||
: opts.positionCaretOnClick),
|
||
(opts.digitsOptional = !1),
|
||
isNaN(opts.digits) && (opts.digits = 2),
|
||
(opts.decimalProtect = !1));
|
||
var mask = "[+]";
|
||
if (
|
||
((mask += autoEscape(opts.prefix, opts)),
|
||
!0 === opts.integerOptional
|
||
? (mask += "~{1," + opts.integerDigits + "}")
|
||
: (mask += "~{" + opts.integerDigits + "}"),
|
||
opts.digits !== undefined)
|
||
) {
|
||
opts.radixPointDefinitionSymbol = opts.decimalProtect
|
||
? ":"
|
||
: opts.radixPoint;
|
||
var dq = opts.digits.toString().split(",");
|
||
isFinite(dq[0] && dq[1] && isFinite(dq[1]))
|
||
? (mask +=
|
||
opts.radixPointDefinitionSymbol +
|
||
";{" +
|
||
opts.digits +
|
||
"}")
|
||
: (isNaN(opts.digits) || parseInt(opts.digits) > 0) &&
|
||
(opts.digitsOptional
|
||
? (mask +=
|
||
"[" +
|
||
opts.radixPointDefinitionSymbol +
|
||
";{1," +
|
||
opts.digits +
|
||
"}]")
|
||
: (mask +=
|
||
opts.radixPointDefinitionSymbol +
|
||
";{" +
|
||
opts.digits +
|
||
"}"));
|
||
}
|
||
return (
|
||
(mask += autoEscape(opts.suffix, opts)),
|
||
(mask += "[-]"),
|
||
(opts.greedy = !1),
|
||
mask
|
||
);
|
||
},
|
||
placeholder: "",
|
||
greedy: !1,
|
||
digits: "*",
|
||
digitsOptional: !0,
|
||
enforceDigitsOnBlur: !1,
|
||
radixPoint: ".",
|
||
positionCaretOnClick: "radixFocus",
|
||
groupSize: 3,
|
||
groupSeparator: "",
|
||
autoGroup: !1,
|
||
allowMinus: !0,
|
||
negationSymbol: {
|
||
front: "-",
|
||
back: "",
|
||
},
|
||
integerDigits: "+",
|
||
integerOptional: !0,
|
||
prefix: "",
|
||
suffix: "",
|
||
rightAlign: !0,
|
||
decimalProtect: !0,
|
||
min: null,
|
||
max: null,
|
||
step: 1,
|
||
insertMode: !0,
|
||
autoUnmask: !1,
|
||
unmaskAsNumber: !1,
|
||
inputmode: "numeric",
|
||
preValidation: function (buffer, pos, c, isSelection, opts) {
|
||
if ("-" === c || c === opts.negationSymbol.front)
|
||
return (
|
||
!0 === opts.allowMinus &&
|
||
((opts.isNegative =
|
||
opts.isNegative === undefined || !opts.isNegative),
|
||
"" === buffer.join("") || {
|
||
caret: pos,
|
||
dopost: !0,
|
||
})
|
||
);
|
||
if (
|
||
!1 === isSelection &&
|
||
c === opts.radixPoint &&
|
||
opts.digits !== undefined &&
|
||
(isNaN(opts.digits) || parseInt(opts.digits) > 0)
|
||
) {
|
||
var radixPos = $.inArray(opts.radixPoint, buffer);
|
||
if (-1 !== radixPos)
|
||
return !0 === opts.numericInput
|
||
? pos === radixPos
|
||
: {
|
||
caret: radixPos + 1,
|
||
};
|
||
}
|
||
return !0;
|
||
},
|
||
postValidation: function (buffer, currentResult, opts) {
|
||
var suffix = opts.suffix.split(""),
|
||
prefix = opts.prefix.split("");
|
||
if (
|
||
currentResult.pos === undefined &&
|
||
currentResult.caret !== undefined &&
|
||
!0 !== currentResult.dopost
|
||
)
|
||
return currentResult;
|
||
var caretPos =
|
||
currentResult.caret !== undefined
|
||
? currentResult.caret
|
||
: currentResult.pos,
|
||
maskedValue = buffer.slice();
|
||
opts.numericInput &&
|
||
((caretPos = maskedValue.length - caretPos - 1),
|
||
(maskedValue = maskedValue.reverse()));
|
||
var charAtPos = maskedValue[caretPos];
|
||
if (
|
||
(charAtPos === opts.groupSeparator &&
|
||
(charAtPos = maskedValue[(caretPos += 1)]),
|
||
caretPos === maskedValue.length - opts.suffix.length - 1 &&
|
||
charAtPos === opts.radixPoint)
|
||
)
|
||
return currentResult;
|
||
charAtPos !== undefined &&
|
||
charAtPos !== opts.radixPoint &&
|
||
charAtPos !== opts.negationSymbol.front &&
|
||
charAtPos !== opts.negationSymbol.back &&
|
||
((maskedValue[caretPos] = "?"),
|
||
opts.prefix.length > 0 &&
|
||
caretPos >= (!1 === opts.isNegative ? 1 : 0) &&
|
||
caretPos <
|
||
opts.prefix.length - 1 + (!1 === opts.isNegative ? 1 : 0)
|
||
? (prefix[caretPos - (!1 === opts.isNegative ? 1 : 0)] = "?")
|
||
: opts.suffix.length > 0 &&
|
||
caretPos >=
|
||
maskedValue.length -
|
||
opts.suffix.length -
|
||
(!1 === opts.isNegative ? 1 : 0) &&
|
||
(suffix[
|
||
caretPos -
|
||
(maskedValue.length -
|
||
opts.suffix.length -
|
||
(!1 === opts.isNegative ? 1 : 0))
|
||
] = "?")),
|
||
(prefix = prefix.join("")),
|
||
(suffix = suffix.join(""));
|
||
var processValue = maskedValue.join("").replace(prefix, "");
|
||
if (
|
||
((processValue = processValue.replace(suffix, "")),
|
||
(processValue = processValue.replace(
|
||
new RegExp(Inputmask.escapeRegex(opts.groupSeparator), "g"),
|
||
""
|
||
)),
|
||
(processValue = processValue.replace(
|
||
new RegExp(
|
||
"[-" +
|
||
Inputmask.escapeRegex(opts.negationSymbol.front) +
|
||
"]",
|
||
"g"
|
||
),
|
||
""
|
||
)),
|
||
(processValue = processValue.replace(
|
||
new RegExp(
|
||
Inputmask.escapeRegex(opts.negationSymbol.back) + "$"
|
||
),
|
||
""
|
||
)),
|
||
isNaN(opts.placeholder) &&
|
||
(processValue = processValue.replace(
|
||
new RegExp(Inputmask.escapeRegex(opts.placeholder), "g"),
|
||
""
|
||
)),
|
||
processValue.length > 1 &&
|
||
1 !== processValue.indexOf(opts.radixPoint) &&
|
||
("0" === charAtPos &&
|
||
(processValue = processValue.replace(/^\?/g, "")),
|
||
(processValue = processValue.replace(/^0/g, ""))),
|
||
processValue.charAt(0) === opts.radixPoint &&
|
||
"" !== opts.radixPoint &&
|
||
!0 !== opts.numericInput &&
|
||
(processValue = "0" + processValue),
|
||
"" !== processValue)
|
||
) {
|
||
if (
|
||
((processValue = processValue.split("")),
|
||
(!opts.digitsOptional ||
|
||
(opts.enforceDigitsOnBlur &&
|
||
"blur" === currentResult.event)) &&
|
||
isFinite(opts.digits))
|
||
) {
|
||
var radixPosition = $.inArray(opts.radixPoint, processValue),
|
||
rpb = $.inArray(opts.radixPoint, maskedValue);
|
||
-1 === radixPosition &&
|
||
(processValue.push(opts.radixPoint),
|
||
(radixPosition = processValue.length - 1));
|
||
for (var i = 1; i <= opts.digits; i++)
|
||
(opts.digitsOptional &&
|
||
(!opts.enforceDigitsOnBlur ||
|
||
"blur" !== currentResult.event)) ||
|
||
(processValue[radixPosition + i] !== undefined &&
|
||
processValue[radixPosition + i] !==
|
||
opts.placeholder.charAt(0))
|
||
? -1 !== rpb &&
|
||
maskedValue[rpb + i] !== undefined &&
|
||
(processValue[radixPosition + i] =
|
||
processValue[radixPosition + i] ||
|
||
maskedValue[rpb + i])
|
||
: (processValue[radixPosition + i] =
|
||
currentResult.placeholder ||
|
||
opts.placeholder.charAt(0));
|
||
}
|
||
if (
|
||
!0 !== opts.autoGroup ||
|
||
"" === opts.groupSeparator ||
|
||
(charAtPos === opts.radixPoint &&
|
||
currentResult.pos === undefined &&
|
||
!currentResult.dopost)
|
||
)
|
||
processValue = processValue.join("");
|
||
else {
|
||
var addRadix =
|
||
processValue[processValue.length - 1] === opts.radixPoint &&
|
||
currentResult.c === opts.radixPoint;
|
||
(processValue = Inputmask(
|
||
(function (buffer, opts) {
|
||
var postMask = "";
|
||
if (
|
||
((postMask +=
|
||
"(" +
|
||
opts.groupSeparator +
|
||
"*{" +
|
||
opts.groupSize +
|
||
"}){*}"),
|
||
"" !== opts.radixPoint)
|
||
) {
|
||
var radixSplit = buffer.join("").split(opts.radixPoint);
|
||
radixSplit[1] &&
|
||
(postMask +=
|
||
opts.radixPoint +
|
||
"*{" +
|
||
radixSplit[1].match(/^\d*\??\d*/)[0].length +
|
||
"}");
|
||
}
|
||
return postMask;
|
||
})(processValue, opts),
|
||
{
|
||
numericInput: !0,
|
||
jitMasking: !0,
|
||
definitions: {
|
||
"*": {
|
||
validator: "[0-9?]",
|
||
cardinality: 1,
|
||
},
|
||
},
|
||
}
|
||
).format(processValue.join(""))),
|
||
addRadix && (processValue += opts.radixPoint),
|
||
processValue.charAt(0) === opts.groupSeparator &&
|
||
processValue.substr(1);
|
||
}
|
||
}
|
||
if (
|
||
(opts.isNegative &&
|
||
"blur" === currentResult.event &&
|
||
(opts.isNegative = "0" !== processValue),
|
||
(processValue = prefix + processValue),
|
||
(processValue += suffix),
|
||
opts.isNegative &&
|
||
((processValue = opts.negationSymbol.front + processValue),
|
||
(processValue += opts.negationSymbol.back)),
|
||
(processValue = processValue.split("")),
|
||
charAtPos !== undefined)
|
||
)
|
||
if (
|
||
charAtPos !== opts.radixPoint &&
|
||
charAtPos !== opts.negationSymbol.front &&
|
||
charAtPos !== opts.negationSymbol.back
|
||
)
|
||
(caretPos = $.inArray("?", processValue)) > -1
|
||
? (processValue[caretPos] = charAtPos)
|
||
: (caretPos = currentResult.caret || 0);
|
||
else if (
|
||
charAtPos === opts.radixPoint ||
|
||
charAtPos === opts.negationSymbol.front ||
|
||
charAtPos === opts.negationSymbol.back
|
||
) {
|
||
var newCaretPos = $.inArray(charAtPos, processValue);
|
||
-1 !== newCaretPos && (caretPos = newCaretPos);
|
||
}
|
||
opts.numericInput &&
|
||
((caretPos = processValue.length - caretPos - 1),
|
||
(processValue = processValue.reverse()));
|
||
var rslt = {
|
||
caret:
|
||
charAtPos === undefined || currentResult.pos !== undefined
|
||
? caretPos + (opts.numericInput ? -1 : 1)
|
||
: caretPos,
|
||
buffer: processValue,
|
||
refreshFromBuffer:
|
||
currentResult.dopost ||
|
||
buffer.join("") !== processValue.join(""),
|
||
};
|
||
return rslt.refreshFromBuffer ? rslt : currentResult;
|
||
},
|
||
onBeforeWrite: function (e, buffer, caretPos, opts) {
|
||
if (e)
|
||
switch (e.type) {
|
||
case "keydown":
|
||
return opts.postValidation(
|
||
buffer,
|
||
{
|
||
caret: caretPos,
|
||
dopost: !0,
|
||
},
|
||
opts
|
||
);
|
||
|
||
case "blur":
|
||
case "checkval":
|
||
var unmasked;
|
||
if (
|
||
((function (opts) {
|
||
opts.parseMinMaxOptions === undefined &&
|
||
(null !== opts.min &&
|
||
((opts.min = opts.min
|
||
.toString()
|
||
.replace(
|
||
new RegExp(
|
||
Inputmask.escapeRegex(opts.groupSeparator),
|
||
"g"
|
||
),
|
||
""
|
||
)),
|
||
"," === opts.radixPoint &&
|
||
(opts.min = opts.min.replace(
|
||
opts.radixPoint,
|
||
"."
|
||
)),
|
||
(opts.min = isFinite(opts.min)
|
||
? parseFloat(opts.min)
|
||
: NaN),
|
||
isNaN(opts.min) && (opts.min = Number.MIN_VALUE)),
|
||
null !== opts.max &&
|
||
((opts.max = opts.max
|
||
.toString()
|
||
.replace(
|
||
new RegExp(
|
||
Inputmask.escapeRegex(opts.groupSeparator),
|
||
"g"
|
||
),
|
||
""
|
||
)),
|
||
"," === opts.radixPoint &&
|
||
(opts.max = opts.max.replace(
|
||
opts.radixPoint,
|
||
"."
|
||
)),
|
||
(opts.max = isFinite(opts.max)
|
||
? parseFloat(opts.max)
|
||
: NaN),
|
||
isNaN(opts.max) && (opts.max = Number.MAX_VALUE)),
|
||
(opts.parseMinMaxOptions = "done"));
|
||
})(opts),
|
||
null !== opts.min || null !== opts.max)
|
||
) {
|
||
if (
|
||
((unmasked = opts.onUnMask(
|
||
buffer.join(""),
|
||
undefined,
|
||
$.extend({}, opts, {
|
||
unmaskAsNumber: !0,
|
||
})
|
||
)),
|
||
null !== opts.min && unmasked < opts.min)
|
||
)
|
||
return (
|
||
(opts.isNegative = opts.min < 0),
|
||
opts.postValidation(
|
||
opts.min
|
||
.toString()
|
||
.replace(".", opts.radixPoint)
|
||
.split(""),
|
||
{
|
||
caret: caretPos,
|
||
dopost: !0,
|
||
placeholder: "0",
|
||
},
|
||
opts
|
||
)
|
||
);
|
||
if (null !== opts.max && unmasked > opts.max)
|
||
return (
|
||
(opts.isNegative = opts.max < 0),
|
||
opts.postValidation(
|
||
opts.max
|
||
.toString()
|
||
.replace(".", opts.radixPoint)
|
||
.split(""),
|
||
{
|
||
caret: caretPos,
|
||
dopost: !0,
|
||
placeholder: "0",
|
||
},
|
||
opts
|
||
)
|
||
);
|
||
}
|
||
return opts.postValidation(
|
||
buffer,
|
||
{
|
||
caret: caretPos,
|
||
placeholder: "0",
|
||
event: "blur",
|
||
},
|
||
opts
|
||
);
|
||
|
||
case "_checkval":
|
||
return {
|
||
caret: caretPos,
|
||
};
|
||
}
|
||
},
|
||
regex: {
|
||
integerPart: function (opts, emptyCheck) {
|
||
return emptyCheck
|
||
? new RegExp(
|
||
"[" +
|
||
Inputmask.escapeRegex(opts.negationSymbol.front) +
|
||
"+]?"
|
||
)
|
||
: new RegExp(
|
||
"[" +
|
||
Inputmask.escapeRegex(opts.negationSymbol.front) +
|
||
"+]?\\d+"
|
||
);
|
||
},
|
||
integerNPart: function (opts) {
|
||
return new RegExp(
|
||
"[\\d" +
|
||
Inputmask.escapeRegex(opts.groupSeparator) +
|
||
Inputmask.escapeRegex(opts.placeholder.charAt(0)) +
|
||
"]+"
|
||
);
|
||
},
|
||
},
|
||
definitions: {
|
||
"~": {
|
||
validator: function (
|
||
chrs,
|
||
maskset,
|
||
pos,
|
||
strict,
|
||
opts,
|
||
isSelection
|
||
) {
|
||
var isValid = strict
|
||
? new RegExp(
|
||
"[0-9" +
|
||
Inputmask.escapeRegex(opts.groupSeparator) +
|
||
"]"
|
||
).test(chrs)
|
||
: new RegExp("[0-9]").test(chrs);
|
||
if (!0 === isValid) {
|
||
if (
|
||
!0 !== opts.numericInput &&
|
||
maskset.validPositions[pos] !== undefined &&
|
||
"~" === maskset.validPositions[pos].match.def &&
|
||
!isSelection
|
||
) {
|
||
var processValue = maskset.buffer.join(""),
|
||
pvRadixSplit = (processValue = (processValue =
|
||
processValue.replace(
|
||
new RegExp(
|
||
"[-" +
|
||
Inputmask.escapeRegex(
|
||
opts.negationSymbol.front
|
||
) +
|
||
"]",
|
||
"g"
|
||
),
|
||
""
|
||
)).replace(
|
||
new RegExp(
|
||
Inputmask.escapeRegex(opts.negationSymbol.back) +
|
||
"$"
|
||
),
|
||
""
|
||
)).split(opts.radixPoint);
|
||
pvRadixSplit.length > 1 &&
|
||
(pvRadixSplit[1] = pvRadixSplit[1].replace(
|
||
/0/g,
|
||
opts.placeholder.charAt(0)
|
||
)),
|
||
"0" === pvRadixSplit[0] &&
|
||
(pvRadixSplit[0] = pvRadixSplit[0].replace(
|
||
/0/g,
|
||
opts.placeholder.charAt(0)
|
||
)),
|
||
(processValue =
|
||
pvRadixSplit[0] + opts.radixPoint + pvRadixSplit[1] ||
|
||
"");
|
||
var bufferTemplate = maskset._buffer.join("");
|
||
for (
|
||
processValue === opts.radixPoint &&
|
||
(processValue = bufferTemplate);
|
||
null ===
|
||
processValue.match(
|
||
Inputmask.escapeRegex(bufferTemplate) + "$"
|
||
);
|
||
|
||
)
|
||
bufferTemplate = bufferTemplate.slice(1);
|
||
isValid =
|
||
(processValue = (processValue = processValue.replace(
|
||
bufferTemplate,
|
||
""
|
||
)).split(""))[pos] === undefined
|
||
? {
|
||
pos: pos,
|
||
remove: pos,
|
||
}
|
||
: {
|
||
pos: pos,
|
||
};
|
||
}
|
||
} else
|
||
strict ||
|
||
chrs !== opts.radixPoint ||
|
||
maskset.validPositions[pos - 1] !== undefined ||
|
||
((maskset.buffer[pos] = "0"),
|
||
(isValid = {
|
||
pos: pos + 1,
|
||
}));
|
||
return isValid;
|
||
},
|
||
cardinality: 1,
|
||
},
|
||
"+": {
|
||
validator: function (chrs, maskset, pos, strict, opts) {
|
||
return (
|
||
opts.allowMinus &&
|
||
("-" === chrs || chrs === opts.negationSymbol.front)
|
||
);
|
||
},
|
||
cardinality: 1,
|
||
placeholder: "",
|
||
},
|
||
"-": {
|
||
validator: function (chrs, maskset, pos, strict, opts) {
|
||
return opts.allowMinus && chrs === opts.negationSymbol.back;
|
||
},
|
||
cardinality: 1,
|
||
placeholder: "",
|
||
},
|
||
":": {
|
||
validator: function (chrs, maskset, pos, strict, opts) {
|
||
var radix =
|
||
"[" + Inputmask.escapeRegex(opts.radixPoint) + "]",
|
||
isValid = new RegExp(radix).test(chrs);
|
||
return (
|
||
isValid &&
|
||
maskset.validPositions[pos] &&
|
||
maskset.validPositions[pos].match.placeholder ===
|
||
opts.radixPoint &&
|
||
(isValid = {
|
||
caret: pos + 1,
|
||
}),
|
||
isValid
|
||
);
|
||
},
|
||
cardinality: 1,
|
||
placeholder: function (opts) {
|
||
return opts.radixPoint;
|
||
},
|
||
},
|
||
},
|
||
onUnMask: function (maskedValue, unmaskedValue, opts) {
|
||
if ("" === unmaskedValue && !0 === opts.nullable)
|
||
return unmaskedValue;
|
||
var processValue = maskedValue.replace(opts.prefix, "");
|
||
return (
|
||
(processValue = processValue.replace(opts.suffix, "")),
|
||
(processValue = processValue.replace(
|
||
new RegExp(Inputmask.escapeRegex(opts.groupSeparator), "g"),
|
||
""
|
||
)),
|
||
"" !== opts.placeholder.charAt(0) &&
|
||
(processValue = processValue.replace(
|
||
new RegExp(opts.placeholder.charAt(0), "g"),
|
||
"0"
|
||
)),
|
||
opts.unmaskAsNumber
|
||
? ("" !== opts.radixPoint &&
|
||
-1 !== processValue.indexOf(opts.radixPoint) &&
|
||
(processValue = processValue.replace(
|
||
Inputmask.escapeRegex.call(this, opts.radixPoint),
|
||
"."
|
||
)),
|
||
(processValue = processValue.replace(
|
||
new RegExp(
|
||
"^" + Inputmask.escapeRegex(opts.negationSymbol.front)
|
||
),
|
||
"-"
|
||
)),
|
||
(processValue = processValue.replace(
|
||
new RegExp(
|
||
Inputmask.escapeRegex(opts.negationSymbol.back) + "$"
|
||
),
|
||
""
|
||
)),
|
||
Number(processValue))
|
||
: processValue
|
||
);
|
||
},
|
||
isComplete: function (buffer, opts) {
|
||
var maskedValue = buffer.join("");
|
||
if (buffer.slice().join("") !== maskedValue) return !1;
|
||
var processValue = maskedValue.replace(opts.prefix, "");
|
||
return (
|
||
(processValue = processValue.replace(opts.suffix, "")),
|
||
(processValue = processValue.replace(
|
||
new RegExp(Inputmask.escapeRegex(opts.groupSeparator), "g"),
|
||
""
|
||
)),
|
||
"," === opts.radixPoint &&
|
||
(processValue = processValue.replace(
|
||
Inputmask.escapeRegex(opts.radixPoint),
|
||
"."
|
||
)),
|
||
isFinite(processValue)
|
||
);
|
||
},
|
||
onBeforeMask: function (initialValue, opts) {
|
||
if (
|
||
((opts.isNegative = undefined),
|
||
(initialValue =
|
||
initialValue.toString().charAt(initialValue.length - 1) ===
|
||
opts.radixPoint
|
||
? initialValue.toString().substr(0, initialValue.length - 1)
|
||
: initialValue.toString()),
|
||
"" !== opts.radixPoint && isFinite(initialValue))
|
||
) {
|
||
var vs = initialValue.split("."),
|
||
groupSize =
|
||
"" !== opts.groupSeparator ? parseInt(opts.groupSize) : 0;
|
||
2 === vs.length &&
|
||
(vs[0].length > groupSize ||
|
||
vs[1].length > groupSize ||
|
||
(vs[0].length <= groupSize && vs[1].length < groupSize)) &&
|
||
(initialValue = initialValue.replace(".", opts.radixPoint));
|
||
}
|
||
var kommaMatches = initialValue.match(/,/g),
|
||
dotMatches = initialValue.match(/\./g);
|
||
if (
|
||
((initialValue =
|
||
dotMatches && kommaMatches
|
||
? dotMatches.length > kommaMatches.length
|
||
? (initialValue = initialValue.replace(
|
||
/\./g,
|
||
""
|
||
)).replace(",", opts.radixPoint)
|
||
: kommaMatches.length > dotMatches.length
|
||
? (initialValue = initialValue.replace(/,/g, "")).replace(
|
||
".",
|
||
opts.radixPoint
|
||
)
|
||
: initialValue.indexOf(".") < initialValue.indexOf(",")
|
||
? initialValue.replace(/\./g, "")
|
||
: initialValue.replace(/,/g, "")
|
||
: initialValue.replace(
|
||
new RegExp(
|
||
Inputmask.escapeRegex(opts.groupSeparator),
|
||
"g"
|
||
),
|
||
""
|
||
)),
|
||
0 === opts.digits &&
|
||
(-1 !== initialValue.indexOf(".")
|
||
? (initialValue = initialValue.substring(
|
||
0,
|
||
initialValue.indexOf(".")
|
||
))
|
||
: -1 !== initialValue.indexOf(",") &&
|
||
(initialValue = initialValue.substring(
|
||
0,
|
||
initialValue.indexOf(",")
|
||
))),
|
||
"" !== opts.radixPoint &&
|
||
isFinite(opts.digits) &&
|
||
-1 !== initialValue.indexOf(opts.radixPoint))
|
||
) {
|
||
var decPart = initialValue
|
||
.split(opts.radixPoint)[1]
|
||
.match(new RegExp("\\d*"))[0];
|
||
if (parseInt(opts.digits) < decPart.toString().length) {
|
||
var digitsFactor = Math.pow(10, parseInt(opts.digits));
|
||
(initialValue = initialValue.replace(
|
||
Inputmask.escapeRegex(opts.radixPoint),
|
||
"."
|
||
)),
|
||
(initialValue = (initialValue =
|
||
Math.round(parseFloat(initialValue) * digitsFactor) /
|
||
digitsFactor)
|
||
.toString()
|
||
.replace(".", opts.radixPoint));
|
||
}
|
||
}
|
||
return initialValue;
|
||
},
|
||
canClearPosition: function (maskset, position, lvp, strict, opts) {
|
||
var vp = maskset.validPositions[position],
|
||
canClear =
|
||
vp.input !== opts.radixPoint ||
|
||
(null !== maskset.validPositions[position].match.fn &&
|
||
!1 === opts.decimalProtect) ||
|
||
(vp.input === opts.radixPoint &&
|
||
maskset.validPositions[position + 1] &&
|
||
null === maskset.validPositions[position + 1].match.fn) ||
|
||
isFinite(vp.input) ||
|
||
position === lvp ||
|
||
vp.input === opts.groupSeparator ||
|
||
vp.input === opts.negationSymbol.front ||
|
||
vp.input === opts.negationSymbol.back;
|
||
return (
|
||
!canClear ||
|
||
("+" !== vp.match.nativeDef && "-" !== vp.match.nativeDef) ||
|
||
(opts.isNegative = !1),
|
||
canClear
|
||
);
|
||
},
|
||
onKeyDown: function (e, buffer, caretPos, opts) {
|
||
var $input = $(this);
|
||
if (e.ctrlKey)
|
||
switch (e.keyCode) {
|
||
case Inputmask.keyCode.UP:
|
||
$input.val(
|
||
parseFloat(this.inputmask.unmaskedvalue()) +
|
||
parseInt(opts.step)
|
||
),
|
||
$input.trigger("setvalue");
|
||
break;
|
||
|
||
case Inputmask.keyCode.DOWN:
|
||
$input.val(
|
||
parseFloat(this.inputmask.unmaskedvalue()) -
|
||
parseInt(opts.step)
|
||
),
|
||
$input.trigger("setvalue");
|
||
}
|
||
},
|
||
},
|
||
currency: {
|
||
prefix: "$ ",
|
||
groupSeparator: ",",
|
||
alias: "numeric",
|
||
placeholder: "0",
|
||
autoGroup: !0,
|
||
digits: 2,
|
||
digitsOptional: !1,
|
||
clearMaskOnLostFocus: !1,
|
||
},
|
||
decimal: {
|
||
alias: "numeric",
|
||
},
|
||
integer: {
|
||
alias: "numeric",
|
||
digits: 0,
|
||
radixPoint: "",
|
||
},
|
||
percentage: {
|
||
alias: "numeric",
|
||
digits: 2,
|
||
digitsOptional: !0,
|
||
radixPoint: ".",
|
||
placeholder: "0",
|
||
autoGroup: !1,
|
||
min: 0,
|
||
max: 100,
|
||
suffix: " %",
|
||
allowMinus: !1,
|
||
},
|
||
}),
|
||
Inputmask
|
||
);
|
||
});
|
||
},
|
||
function (module, exports, __webpack_require__) {
|
||
"use strict";
|
||
var __WEBPACK_AMD_DEFINE_FACTORY__,
|
||
__WEBPACK_AMD_DEFINE_ARRAY__,
|
||
__WEBPACK_AMD_DEFINE_RESULT__;
|
||
"function" == typeof Symbol && Symbol.iterator;
|
||
!(function (factory) {
|
||
(__WEBPACK_AMD_DEFINE_ARRAY__ = [
|
||
__webpack_require__(0),
|
||
__webpack_require__(1),
|
||
]),
|
||
void 0 !==
|
||
(__WEBPACK_AMD_DEFINE_RESULT__ =
|
||
"function" == typeof (__WEBPACK_AMD_DEFINE_FACTORY__ = factory)
|
||
? __WEBPACK_AMD_DEFINE_FACTORY__.apply(
|
||
exports,
|
||
__WEBPACK_AMD_DEFINE_ARRAY__
|
||
)
|
||
: __WEBPACK_AMD_DEFINE_FACTORY__) &&
|
||
(module.exports = __WEBPACK_AMD_DEFINE_RESULT__);
|
||
})(function ($, Inputmask) {
|
||
function maskSort(a, b) {
|
||
var maska = (a.mask || a)
|
||
.replace(/#/g, "9")
|
||
.replace(/\)/, "9")
|
||
.replace(/[+()#-]/g, ""),
|
||
maskb = (b.mask || b)
|
||
.replace(/#/g, "9")
|
||
.replace(/\)/, "9")
|
||
.replace(/[+()#-]/g, ""),
|
||
maskas = (a.mask || a).split("#")[0],
|
||
maskbs = (b.mask || b).split("#")[0];
|
||
return 0 === maskbs.indexOf(maskas)
|
||
? -1
|
||
: 0 === maskas.indexOf(maskbs)
|
||
? 1
|
||
: maska.localeCompare(maskb);
|
||
}
|
||
var analyseMaskBase = Inputmask.prototype.analyseMask;
|
||
return (
|
||
(Inputmask.prototype.analyseMask = function (mask, regexMask, opts) {
|
||
function reduceVariations(
|
||
masks,
|
||
previousVariation,
|
||
previousmaskGroup
|
||
) {
|
||
(previousVariation = previousVariation || ""),
|
||
(previousmaskGroup = previousmaskGroup || maskGroups),
|
||
"" !== previousVariation &&
|
||
(previousmaskGroup[previousVariation] = {});
|
||
for (
|
||
var variation = "",
|
||
maskGroup =
|
||
previousmaskGroup[previousVariation] || previousmaskGroup,
|
||
i = masks.length - 1;
|
||
i >= 0;
|
||
i--
|
||
)
|
||
(maskGroup[
|
||
(variation = (mask = masks[i].mask || masks[i]).substr(0, 1))
|
||
] = maskGroup[variation] || []),
|
||
maskGroup[variation].unshift(mask.substr(1)),
|
||
masks.splice(i, 1);
|
||
for (var ndx in maskGroup)
|
||
maskGroup[ndx].length > 500 &&
|
||
reduceVariations(maskGroup[ndx].slice(), ndx, maskGroup);
|
||
}
|
||
function rebuild(maskGroup) {
|
||
var mask = "",
|
||
submasks = [];
|
||
for (var ndx in maskGroup)
|
||
$.isArray(maskGroup[ndx])
|
||
? 1 === maskGroup[ndx].length
|
||
? submasks.push(ndx + maskGroup[ndx])
|
||
: submasks.push(
|
||
ndx +
|
||
opts.groupmarker.start +
|
||
maskGroup[ndx].join(
|
||
opts.groupmarker.end +
|
||
opts.alternatormarker +
|
||
opts.groupmarker.start
|
||
) +
|
||
opts.groupmarker.end
|
||
)
|
||
: submasks.push(ndx + rebuild(maskGroup[ndx]));
|
||
return (
|
||
1 === submasks.length
|
||
? (mask += submasks[0])
|
||
: (mask +=
|
||
opts.groupmarker.start +
|
||
submasks.join(
|
||
opts.groupmarker.end +
|
||
opts.alternatormarker +
|
||
opts.groupmarker.start
|
||
) +
|
||
opts.groupmarker.end),
|
||
mask
|
||
);
|
||
}
|
||
var maskGroups = {};
|
||
return (
|
||
opts.phoneCodes &&
|
||
(opts.phoneCodes &&
|
||
opts.phoneCodes.length > 1e3 &&
|
||
(reduceVariations(
|
||
(mask = mask.substr(1, mask.length - 2)).split(
|
||
opts.groupmarker.end +
|
||
opts.alternatormarker +
|
||
opts.groupmarker.start
|
||
)
|
||
),
|
||
(mask = rebuild(maskGroups))),
|
||
(mask = mask.replace(/9/g, "\\9"))),
|
||
analyseMaskBase.call(this, mask, regexMask, opts)
|
||
);
|
||
}),
|
||
Inputmask.extendAliases({
|
||
abstractphone: {
|
||
groupmarker: {
|
||
start: "<",
|
||
end: ">",
|
||
},
|
||
countrycode: "",
|
||
phoneCodes: [],
|
||
mask: function (opts) {
|
||
return (
|
||
(opts.definitions = {
|
||
"#": Inputmask.prototype.definitions[9],
|
||
}),
|
||
opts.phoneCodes.sort(maskSort)
|
||
);
|
||
},
|
||
keepStatic: !0,
|
||
onBeforeMask: function (value, opts) {
|
||
var processedValue = value
|
||
.replace(/^0{1,2}/, "")
|
||
.replace(/[\s]/g, "");
|
||
return (
|
||
(processedValue.indexOf(opts.countrycode) > 1 ||
|
||
-1 === processedValue.indexOf(opts.countrycode)) &&
|
||
(processedValue = "+" + opts.countrycode + processedValue),
|
||
processedValue
|
||
);
|
||
},
|
||
onUnMask: function (maskedValue, unmaskedValue, opts) {
|
||
return maskedValue.replace(/[()#-]/g, "");
|
||
},
|
||
inputmode: "tel",
|
||
},
|
||
}),
|
||
Inputmask
|
||
);
|
||
});
|
||
},
|
||
function (module, exports, __webpack_require__) {
|
||
"use strict";
|
||
var __WEBPACK_AMD_DEFINE_FACTORY__,
|
||
__WEBPACK_AMD_DEFINE_ARRAY__,
|
||
__WEBPACK_AMD_DEFINE_RESULT__;
|
||
"function" == typeof Symbol && Symbol.iterator;
|
||
!(function (factory) {
|
||
(__WEBPACK_AMD_DEFINE_ARRAY__ = [
|
||
__webpack_require__(0),
|
||
__webpack_require__(1),
|
||
]),
|
||
void 0 !==
|
||
(__WEBPACK_AMD_DEFINE_RESULT__ =
|
||
"function" == typeof (__WEBPACK_AMD_DEFINE_FACTORY__ = factory)
|
||
? __WEBPACK_AMD_DEFINE_FACTORY__.apply(
|
||
exports,
|
||
__WEBPACK_AMD_DEFINE_ARRAY__
|
||
)
|
||
: __WEBPACK_AMD_DEFINE_FACTORY__) &&
|
||
(module.exports = __WEBPACK_AMD_DEFINE_RESULT__);
|
||
})(function ($, Inputmask) {
|
||
return (
|
||
Inputmask.extendAliases({
|
||
Regex: {
|
||
mask: "r",
|
||
greedy: !1,
|
||
repeat: "*",
|
||
regex: null,
|
||
regexTokens: null,
|
||
tokenizer:
|
||
/\[\^?]?(?:[^\\\]]+|\\[\S\s]?)*]?|\\(?:0(?:[0-3][0-7]{0,2}|[4-7][0-7]?)?|[1-9][0-9]*|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|c[A-Za-z]|[\S\s]?)|\((?:\?[:=!]?)?|(?:[?*+]|\{[0-9]+(?:,[0-9]*)?\})\??|[^.?*+^${[()|\\]+|./g,
|
||
quantifierFilter: /[0-9]+[^,]/,
|
||
isComplete: function (buffer, opts) {
|
||
return new RegExp(opts.regex, opts.casing ? "i" : "").test(
|
||
buffer.join("")
|
||
);
|
||
},
|
||
definitions: {
|
||
r: {
|
||
validator: function (chrs, maskset, pos, strict, opts) {
|
||
function RegexToken(isGroup, isQuantifier) {
|
||
(this.matches = []),
|
||
(this.isGroup = isGroup || !1),
|
||
(this.isQuantifier = isQuantifier || !1),
|
||
(this.quantifier = {
|
||
min: 1,
|
||
max: 1,
|
||
}),
|
||
(this.repeaterPart = void 0);
|
||
}
|
||
function validateRegexToken(token, fromGroup) {
|
||
var isvalid = !1;
|
||
fromGroup && ((regexPart += "("), openGroupCount++);
|
||
for (var mndx = 0; mndx < token.matches.length; mndx++) {
|
||
var matchToken = token.matches[mndx];
|
||
if (!0 === matchToken.isGroup)
|
||
isvalid = validateRegexToken(matchToken, !0);
|
||
else if (!0 === matchToken.isQuantifier) {
|
||
var crrntndx = $.inArray(matchToken, token.matches),
|
||
matchGroup = token.matches[crrntndx - 1],
|
||
regexPartBak = regexPart;
|
||
if (isNaN(matchToken.quantifier.max)) {
|
||
for (
|
||
;
|
||
matchToken.repeaterPart &&
|
||
matchToken.repeaterPart !== regexPart &&
|
||
matchToken.repeaterPart.length > regexPart.length &&
|
||
!(isvalid = validateRegexToken(matchGroup, !0));
|
||
|
||
);
|
||
(isvalid =
|
||
isvalid || validateRegexToken(matchGroup, !0)) &&
|
||
(matchToken.repeaterPart = regexPart),
|
||
(regexPart =
|
||
regexPartBak + matchToken.quantifier.max);
|
||
} else {
|
||
for (
|
||
var i = 0, qm = matchToken.quantifier.max - 1;
|
||
i < qm &&
|
||
!(isvalid = validateRegexToken(matchGroup, !0));
|
||
i++
|
||
);
|
||
regexPart =
|
||
regexPartBak +
|
||
"{" +
|
||
matchToken.quantifier.min +
|
||
"," +
|
||
matchToken.quantifier.max +
|
||
"}";
|
||
}
|
||
} else if (void 0 !== matchToken.matches)
|
||
for (
|
||
var k = 0;
|
||
k < matchToken.length &&
|
||
!(isvalid = validateRegexToken(
|
||
matchToken[k],
|
||
fromGroup
|
||
));
|
||
k++
|
||
);
|
||
else {
|
||
var testExp;
|
||
if ("[" == matchToken.charAt(0)) {
|
||
(testExp = regexPart), (testExp += matchToken);
|
||
for (j = 0; j < openGroupCount; j++) testExp += ")";
|
||
isvalid = (exp = new RegExp(
|
||
"^(" + testExp + ")$",
|
||
opts.casing ? "i" : ""
|
||
)).test(bufferStr);
|
||
} else
|
||
for (var l = 0, tl = matchToken.length; l < tl; l++)
|
||
if ("\\" !== matchToken.charAt(l)) {
|
||
(testExp = regexPart),
|
||
(testExp = (testExp += matchToken.substr(
|
||
0,
|
||
l + 1
|
||
)).replace(/\|$/, ""));
|
||
for (var j = 0; j < openGroupCount; j++)
|
||
testExp += ")";
|
||
var exp = new RegExp(
|
||
"^(" + testExp + ")$",
|
||
opts.casing ? "i" : ""
|
||
);
|
||
if ((isvalid = exp.test(bufferStr))) break;
|
||
}
|
||
regexPart += matchToken;
|
||
}
|
||
if (isvalid) break;
|
||
}
|
||
return (
|
||
fromGroup && ((regexPart += ")"), openGroupCount--),
|
||
isvalid
|
||
);
|
||
}
|
||
var bufferStr,
|
||
groupToken,
|
||
cbuffer = maskset.buffer.slice(),
|
||
regexPart = "",
|
||
isValid = !1,
|
||
openGroupCount = 0;
|
||
null === opts.regexTokens &&
|
||
(function () {
|
||
var match,
|
||
m,
|
||
currentToken = new RegexToken(),
|
||
opengroups = [];
|
||
for (
|
||
opts.regexTokens = [];
|
||
(match = opts.tokenizer.exec(opts.regex));
|
||
|
||
)
|
||
switch ((m = match[0]).charAt(0)) {
|
||
case "(":
|
||
opengroups.push(new RegexToken(!0));
|
||
break;
|
||
|
||
case ")":
|
||
(groupToken = opengroups.pop()),
|
||
opengroups.length > 0
|
||
? opengroups[
|
||
opengroups.length - 1
|
||
].matches.push(groupToken)
|
||
: currentToken.matches.push(groupToken);
|
||
break;
|
||
|
||
case "{":
|
||
case "+":
|
||
case "*":
|
||
var quantifierToken = new RegexToken(!1, !0),
|
||
mq = (m = m.replace(/[{}]/g, "")).split(","),
|
||
mq0 = isNaN(mq[0]) ? mq[0] : parseInt(mq[0]),
|
||
mq1 =
|
||
1 === mq.length
|
||
? mq0
|
||
: isNaN(mq[1])
|
||
? mq[1]
|
||
: parseInt(mq[1]);
|
||
if (
|
||
((quantifierToken.quantifier = {
|
||
min: mq0,
|
||
max: mq1,
|
||
}),
|
||
opengroups.length > 0)
|
||
) {
|
||
var matches =
|
||
opengroups[opengroups.length - 1].matches;
|
||
(match = matches.pop()).isGroup ||
|
||
((groupToken = new RegexToken(!0)).matches.push(
|
||
match
|
||
),
|
||
(match = groupToken)),
|
||
matches.push(match),
|
||
matches.push(quantifierToken);
|
||
} else
|
||
(match = currentToken.matches.pop()).isGroup ||
|
||
((groupToken = new RegexToken(!0)).matches.push(
|
||
match
|
||
),
|
||
(match = groupToken)),
|
||
currentToken.matches.push(match),
|
||
currentToken.matches.push(quantifierToken);
|
||
break;
|
||
|
||
default:
|
||
opengroups.length > 0
|
||
? opengroups[opengroups.length - 1].matches.push(
|
||
m
|
||
)
|
||
: currentToken.matches.push(m);
|
||
}
|
||
currentToken.matches.length > 0 &&
|
||
opts.regexTokens.push(currentToken);
|
||
})(),
|
||
cbuffer.splice(pos, 0, chrs),
|
||
(bufferStr = cbuffer.join(""));
|
||
for (var i = 0; i < opts.regexTokens.length; i++) {
|
||
var regexToken = opts.regexTokens[i];
|
||
if (
|
||
(isValid = validateRegexToken(
|
||
regexToken,
|
||
regexToken.isGroup
|
||
))
|
||
)
|
||
break;
|
||
}
|
||
return isValid;
|
||
},
|
||
cardinality: 1,
|
||
},
|
||
},
|
||
},
|
||
}),
|
||
Inputmask
|
||
);
|
||
});
|
||
},
|
||
function (module, exports, __webpack_require__) {
|
||
"use strict";
|
||
var __WEBPACK_AMD_DEFINE_FACTORY__,
|
||
__WEBPACK_AMD_DEFINE_ARRAY__,
|
||
__WEBPACK_AMD_DEFINE_RESULT__,
|
||
_typeof =
|
||
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
|
||
? function (obj) {
|
||
return typeof obj;
|
||
}
|
||
: function (obj) {
|
||
return obj &&
|
||
"function" == typeof Symbol &&
|
||
obj.constructor === Symbol &&
|
||
obj !== Symbol.prototype
|
||
? "symbol"
|
||
: typeof obj;
|
||
};
|
||
!(function (factory) {
|
||
(__WEBPACK_AMD_DEFINE_ARRAY__ = [
|
||
__webpack_require__(2),
|
||
__webpack_require__(1),
|
||
]),
|
||
void 0 !==
|
||
(__WEBPACK_AMD_DEFINE_RESULT__ =
|
||
"function" == typeof (__WEBPACK_AMD_DEFINE_FACTORY__ = factory)
|
||
? __WEBPACK_AMD_DEFINE_FACTORY__.apply(
|
||
exports,
|
||
__WEBPACK_AMD_DEFINE_ARRAY__
|
||
)
|
||
: __WEBPACK_AMD_DEFINE_FACTORY__) &&
|
||
(module.exports = __WEBPACK_AMD_DEFINE_RESULT__);
|
||
})(function ($, Inputmask) {
|
||
return (
|
||
void 0 === $.fn.inputmask &&
|
||
($.fn.inputmask = function (fn, options) {
|
||
var nptmask,
|
||
input = this[0];
|
||
if ((void 0 === options && (options = {}), "string" == typeof fn))
|
||
switch (fn) {
|
||
case "unmaskedvalue":
|
||
return input && input.inputmask
|
||
? input.inputmask.unmaskedvalue()
|
||
: $(input).val();
|
||
|
||
case "remove":
|
||
return this.each(function () {
|
||
this.inputmask && this.inputmask.remove();
|
||
});
|
||
|
||
case "getemptymask":
|
||
return input && input.inputmask
|
||
? input.inputmask.getemptymask()
|
||
: "";
|
||
|
||
case "hasMaskedValue":
|
||
return (
|
||
!(!input || !input.inputmask) &&
|
||
input.inputmask.hasMaskedValue()
|
||
);
|
||
|
||
case "isComplete":
|
||
return (
|
||
!input || !input.inputmask || input.inputmask.isComplete()
|
||
);
|
||
|
||
case "getmetadata":
|
||
return input && input.inputmask
|
||
? input.inputmask.getmetadata()
|
||
: void 0;
|
||
|
||
case "setvalue":
|
||
$(input).val(options),
|
||
input &&
|
||
void 0 === input.inputmask &&
|
||
$(input).triggerHandler("setvalue");
|
||
break;
|
||
|
||
case "option":
|
||
if ("string" != typeof options)
|
||
return this.each(function () {
|
||
if (void 0 !== this.inputmask)
|
||
return this.inputmask.option(options);
|
||
});
|
||
if (input && void 0 !== input.inputmask)
|
||
return input.inputmask.option(options);
|
||
break;
|
||
|
||
default:
|
||
return (
|
||
(options.alias = fn),
|
||
(nptmask = new Inputmask(options)),
|
||
this.each(function () {
|
||
nptmask.mask(this);
|
||
})
|
||
);
|
||
}
|
||
else {
|
||
if ("object" == (void 0 === fn ? "undefined" : _typeof(fn)))
|
||
return (
|
||
(nptmask = new Inputmask(fn)),
|
||
void 0 === fn.mask && void 0 === fn.alias
|
||
? this.each(function () {
|
||
if (void 0 !== this.inputmask)
|
||
return this.inputmask.option(fn);
|
||
nptmask.mask(this);
|
||
})
|
||
: this.each(function () {
|
||
nptmask.mask(this);
|
||
})
|
||
);
|
||
if (void 0 === fn)
|
||
return this.each(function () {
|
||
(nptmask = new Inputmask(options)).mask(this);
|
||
});
|
||
}
|
||
}),
|
||
$.fn.inputmask
|
||
);
|
||
});
|
||
},
|
||
]);
|