use-mask-input 3.0.6 → 3.1.1

package/node_modules/inputmask/lib/validation.js

@@ -1,664 +0,0 @@
-import {
-	determineTestTemplate,
-	getDecisionTaker,
-	getPlaceholder,
-	getTest,
-	getTests,
-	getTestTemplate
-} from "./validation-tests";
-import keyCode from "./keycode.json";
-import {
-	determineLastRequiredPosition, determineNewCaretPosition,
-	getBuffer,
-	getLastValidPosition,
-	isMask,
-	resetMaskSet,
-	seekNext,
-	seekPrevious
-} from "./positioning";
-import { EventHandlers } from "./eventhandlers";
-
-export { alternate, checkAlternationMatch, isComplete, isSelection, isValid, refreshFromBuffer, revalidateMask, handleRemove };
-
-//tobe put on prototype?
-function alternate(maskPos, c, strict, fromIsValid, rAltPos, selection) { //pos == true => generalize
-	const inputmask = this,
-		$ = this.dependencyLib,
-		opts = this.opts,
-		maskset = inputmask.maskset;
-
-	var validPsClone = $.extend(true, {}, maskset.validPositions),
-		tstClone = $.extend(true, {}, maskset.tests),
-		lastAlt,
-		alternation,
-		isValidRslt = false, returnRslt = false,
-		altPos, prevAltPos, i, validPos,
-		decisionPos,
-		lAltPos = rAltPos !== undefined ? rAltPos : getLastValidPosition.call(inputmask), nextPos, input, begin, end;
-
-	if (selection) {
-		begin = selection.begin;
-		end = selection.end;
-		if (selection.begin > selection.end) {
-			begin = selection.end;
-			end = selection.begin;
-		}
-	}
-	if (lAltPos === -1 && rAltPos === undefined) { //do not recurse when already paste the beginning
-		lastAlt = 0;
-		prevAltPos = getTest.call(inputmask, lastAlt);
-		alternation = prevAltPos.alternation;
-	} else {
-		//find last modified alternation
-		for (; lAltPos >= 0; lAltPos--) {
-			altPos = maskset.validPositions[lAltPos];
-			if (altPos && altPos.alternation !== undefined) {
-				if (prevAltPos && prevAltPos.locator[altPos.alternation] !== altPos.locator[altPos.alternation]) {
-					break;
-				}
-				lastAlt = lAltPos;
-				alternation = maskset.validPositions[lastAlt].alternation;
-				prevAltPos = altPos;
-			}
-		}
-	}
-
-	if (alternation !== undefined) {
-		decisionPos = parseInt(lastAlt);
-		maskset.excludes[decisionPos] = maskset.excludes[decisionPos] || [];
-		if (maskPos !== true) { //generalize
-			maskset.excludes[decisionPos].push(getDecisionTaker(prevAltPos) + ":" + prevAltPos.alternation);
-		}
-
-		var validInputs = [], resultPos = -1;
-		for (i = decisionPos; i < getLastValidPosition.call(inputmask, undefined, true) + 1; i++) {
-			if (resultPos === -1 && maskPos <= i && c !== undefined) {
-				validInputs.push(c);
-				resultPos = validInputs.length - 1;
-			}
-			validPos = maskset.validPositions[i];
-			if (validPos && validPos.generatedInput !== true && (selection === undefined || (i < begin || i >= end))) {
-				validInputs.push(validPos.input);
-			}
-			delete maskset.validPositions[i];
-		}
-		if (resultPos === -1 && c !== undefined) {
-			validInputs.push(c);
-			resultPos = validInputs.length - 1;
-		}
-
-		while (maskset.excludes[decisionPos] !== undefined && maskset.excludes[decisionPos].length < 10) {
-			// maskset.tests[decisionPos] = undefined; //clear decisionPos
-			maskset.tests = {};  //clear all
-			resetMaskSet.call(inputmask, true); //clear getbuffer
-			isValidRslt = true;
-			for (i = 0; i < validInputs.length; i++) {
-				nextPos = isValidRslt.caret || (getLastValidPosition.call(inputmask, undefined, true) + 1);
-				input = validInputs[i];
-				// nextPos = translatePosition.call(inputmask, nextPos);
-				if (!(isValidRslt = isValid.call(inputmask, nextPos, input, false, fromIsValid, true))) {
-					break;
-				}
-				if (i === resultPos) {
-					returnRslt = isValidRslt;
-				}
-				if (maskPos == true && isValidRslt) {  //return validposition on generalise
-					returnRslt = { caretPos: i };
-				}
-			}
-			if (!isValidRslt) {
-				resetMaskSet.call(inputmask);
-				prevAltPos = getTest.call(inputmask, decisionPos);  //get the current decisionPos to exclude ~ needs to be before restoring the initial validation
-				//reset & revert
-				maskset.validPositions = $.extend(true, {}, validPsClone);
-				maskset.tests = $.extend(true, {}, tstClone); //refresh tests after possible alternating
-				if (maskset.excludes[decisionPos]) {
-					var decisionTaker = getDecisionTaker(prevAltPos);
-					if (maskset.excludes[decisionPos].indexOf(decisionTaker + ":" + prevAltPos.alternation) !== -1) {
-						returnRslt = alternate.call(inputmask, maskPos, c, strict, fromIsValid, decisionPos - 1, selection);
-						break;
-					}
-					maskset.excludes[decisionPos].push(decisionTaker + ":" + prevAltPos.alternation);
-					for (i = decisionPos; i < getLastValidPosition.call(inputmask, undefined, true) + 1; i++) delete maskset.validPositions[i];
-				} else { //latest alternation
-					returnRslt = alternate.call(inputmask, maskPos, c, strict, fromIsValid, decisionPos - 1, selection);
-					break;
-				}
-			} else {
-				break;
-			}
-		}
-	}
-	//reset alternation excludes
-	if (!returnRslt || opts.keepStatic !== false) {
-		delete maskset.excludes[decisionPos];
-	}
-	return returnRslt;
-}
-
-function casing(elem, test, pos) {
-	const opts = this.opts,
-		maskset = this.maskset;
-
-	switch (opts.casing || test.casing) {
-		case "upper":
-			elem = elem.toUpperCase();
-			break;
-		case "lower":
-			elem = elem.toLowerCase();
-			break;
-		case "title":
-			var posBefore = maskset.validPositions[pos - 1];
-			if (pos === 0 || posBefore && posBefore.input === String.fromCharCode(keyCode.SPACE)) {
-				elem = elem.toUpperCase();
-			} else {
-				elem = elem.toLowerCase();
-			}
-			break;
-		default:
-			if (typeof opts.casing === "function") {
-				var args = Array.prototype.slice.call(arguments);
-				args.push(maskset.validPositions);
-				elem = opts.casing.apply(this, args);
-			}
-	}
-
-	return elem;
-}
-
-//tobe put on prototype?
-function checkAlternationMatch(altArr1, altArr2, na) {
-	const opts = this.opts;
-
-	var altArrC = opts.greedy ? altArr2 : altArr2.slice(0, 1),
-		isMatch = false,
-		naArr = na !== undefined ? na.split(",") : [],
-		naNdx;
-
-	//remove no alternate indexes from alternation array
-	for (var i = 0; i < naArr.length; i++) {
-		if ((naNdx = altArr1.indexOf(naArr[i])) !== -1) {
-			altArr1.splice(naNdx, 1);
-		}
-	}
-
-	for (var alndx = 0; alndx < altArr1.length; alndx++) {
-		if (altArrC.includes(altArr1[alndx])) {
-			isMatch = true;
-			break;
-		}
-	}
-	return isMatch;
-}
-
-//tobe put on prototype?
-function handleRemove(input, k, pos, strict, fromIsValid) {
-	const inputmask = this, maskset = this.maskset, opts = this.opts;
-
-	if (opts.numericInput || inputmask.isRTL) {
-		if (k === keyCode.BACKSPACE) {
-			k = keyCode.DELETE;
-		} else if (k === keyCode.DELETE) {
-			k = keyCode.BACKSPACE;
-		}
-
-		if (inputmask.isRTL) {
-			var pend = pos.end;
-			pos.end = pos.begin;
-			pos.begin = pend;
-		}
-	}
-
-	var lvp = getLastValidPosition.call(inputmask, undefined, true);
-	if (pos.end >= getBuffer.call(inputmask).length && lvp >= pos.end) { //handle numeric negate symbol offset, due to  dynamic jit masking
-		pos.end = lvp + 1;
-	}
-
-	if (k === keyCode.BACKSPACE) {
-		if ((pos.end - pos.begin < 1)) {
-			pos.begin = seekPrevious.call(inputmask, pos.begin);
-		}
-	} else if (k === keyCode.DELETE) {
-		if (pos.begin === pos.end) {
-			pos.end = isMask.call(inputmask, pos.end, true, true) ? pos.end + 1 : seekNext.call(inputmask, pos.end) + 1;
-		}
-	}
-	var offset;
-	if ((offset = revalidateMask.call(inputmask, pos)) !== false) {
-		if (strict !== true && opts.keepStatic !== false || (opts.regex !== null && getTest.call(inputmask, pos.begin).match.def.indexOf("|") !== -1)) { //TODO NEEDS BETTER CHECK WHEN TO ALTERNATE  ~ opts regex isn"t good enough
-			var result = alternate.call(inputmask, true);
-			if (result) {
-				var newPos = result.caret !== undefined ? result.caret : (result.pos ? seekNext.call(inputmask, result.pos.begin ? result.pos.begin : result.pos) : getLastValidPosition.call(inputmask, -1, true));
-				if (k !== keyCode.DELETE || pos.begin > newPos) {
-					pos.begin == newPos;
-				}
-			}
-		}
-
-		if (strict !== true) {
-			maskset.p = k === keyCode.DELETE ? pos.begin + offset : pos.begin;
-			maskset.p = determineNewCaretPosition.call(inputmask, {
-				begin: maskset.p,
-				end: maskset.p
-			}, false, opts.insertMode === false && k === keyCode.BACKSPACE ? "none" : undefined).begin;
-		}
-	}
-}
-
-//tobe put on prototype?
-function isComplete(buffer) { //return true / false / undefined (repeat *)
-	const inputmask = this, opts = this.opts, maskset = this.maskset;
-
-	if (typeof opts.isComplete === "function") return opts.isComplete(buffer, opts);
-	if (opts.repeat === "*") return undefined;
-	var complete = false,
-		lrp = determineLastRequiredPosition.call(inputmask, true),
-		aml = seekPrevious.call(inputmask, lrp.l);
-
-	if (lrp.def === undefined || lrp.def.newBlockMarker || lrp.def.optionality || lrp.def.optionalQuantifier) {
-		complete = true;
-		for (var i = 0; i <= aml; i++) {
-			var test = getTestTemplate.call(inputmask, i).match;
-			if ((test.static !== true && maskset.validPositions[i] === undefined && test.optionality !== true && test.optionalQuantifier !== true) || (test.static === true && buffer[i] !== getPlaceholder.call(inputmask, i, test))) {
-				complete = false;
-				break;
-			}
-		}
-	}
-	return complete;
-}
-
-function isSelection(posObj) {
-	const inputmask = this,
-		opts = this.opts, insertModeOffset = opts.insertMode ? 0 : 1;
-	return inputmask.isRTL ? (posObj.begin - posObj.end) > insertModeOffset : (posObj.end - posObj.begin) > insertModeOffset;
-}
-
-//tobe put on prototype?
-function isValid(pos, c, strict, fromIsValid, fromAlternate, validateOnly, fromCheckval) { //strict true ~ no correction or autofill
-	const inputmask = this,
-		$ = this.dependencyLib,
-		opts = this.opts,
-		maskset = inputmask.maskset;
-
-	strict = strict === true; //always set a value to strict to prevent possible strange behavior in the extensions
-
-	var maskPos = pos;
-	if (pos.begin !== undefined) { //position was a position object - used to handle a delete by typing over a selection
-		maskPos = inputmask.isRTL ? pos.end : pos.begin;
-	}
-
-	function processCommandObject(commandObj) {
-		if (commandObj !== undefined) {
-			if (commandObj.remove !== undefined) { //remove position(s)
-				if (!Array.isArray(commandObj.remove)) commandObj.remove = [commandObj.remove];
-				commandObj.remove.sort(function (a, b) {
-					return b.pos - a.pos;
-				}).forEach(function (lmnt) {
-					revalidateMask.call(inputmask, { begin: lmnt, end: lmnt + 1 });
-				});
-				commandObj.remove = undefined;
-			}
-			if (commandObj.insert !== undefined) { //insert position(s)
-				if (!Array.isArray(commandObj.insert)) commandObj.insert = [commandObj.insert];
-				commandObj.insert.sort(function (a, b) {
-					return a.pos - b.pos;
-				}).forEach(function (lmnt) {
-					if (lmnt.c !== "") {
-						isValid.call(inputmask, lmnt.pos, lmnt.c, lmnt.strict !== undefined ? lmnt.strict : true, lmnt.fromIsValid !== undefined ? lmnt.fromIsValid : fromIsValid);
-					}
-				});
-				commandObj.insert = undefined;
-			}
-
-			if (commandObj.refreshFromBuffer && commandObj.buffer) {
-				var refresh = commandObj.refreshFromBuffer;
-				refreshFromBuffer.call(inputmask, refresh === true ? refresh : refresh.start, refresh.end, commandObj.buffer);
-				commandObj.refreshFromBuffer = undefined;
-			}
-
-			if (commandObj.rewritePosition !== undefined) {
-				maskPos = commandObj.rewritePosition;
-				// commandObj.rewritePosition = undefined;
-				commandObj = true;
-			}
-		}
-		return commandObj;
-	}
-
-	function _isValid(position, c, strict) {
-		var rslt = false;
-		getTests.call(inputmask, position).every(function (tst, ndx) {
-			var test = tst.match;
-			//make sure the buffer is set and correct
-			getBuffer.call(inputmask, true);
-			if (test.jit && maskset.validPositions[seekPrevious.call(inputmask, position)] === undefined) //ignore if jit is not desirable
-			{
-				rslt = false;
-			} else {
-				//return is false or a json object => { pos: ??, c: ??} or true
-				rslt = test.fn != null ?
-					test.fn.test(c, maskset, position, strict, opts, isSelection.call(inputmask, pos)) : (c === test.def || c === opts.skipOptionalPartCharacter) && test.def !== "" ? //non mask
-						{
-							c: getPlaceholder.call(inputmask, position, test, true) || test.def,
-							pos: position
-						} : false;
-			}
-			if (rslt !== false) {
-				var elem = rslt.c !== undefined ? rslt.c : c, validatedPos = position;
-				elem = (elem === opts.skipOptionalPartCharacter && test.static === true) ?
-					(getPlaceholder.call(inputmask, position, test, true) || test.def) : elem;
-
-				rslt = processCommandObject(rslt);
-
-				if (rslt !== true && rslt.pos !== undefined && rslt.pos !== position) { //their is a position offset
-					validatedPos = rslt.pos;
-				}
-
-				if (rslt !== true && rslt.pos === undefined && rslt.c === undefined) {
-					return false; //breakout if nothing to insert
-				}
-
-				if (revalidateMask.call(inputmask, pos, $.extend({}, tst, {
-					"input": casing.call(inputmask, elem, test, validatedPos)
-				}), fromIsValid, validatedPos) === false) {
-					rslt = false;
-				}
-				return false; //break from loop
-			}
-
-			return true;
-		});
-		return rslt;
-	}
-
-	var result = true,
-		positionsClone = $.extend(true, {}, maskset.validPositions); //clone the currentPositions
-
-	if (opts.keepStatic === false && maskset.excludes[maskPos] !== undefined && fromAlternate !== true && fromIsValid !== true) {
-		for (var i = maskPos; i < (inputmask.isRTL ? pos.begin : pos.end); i++) {
-			if (maskset.excludes[i] !== undefined) {
-				maskset.excludes[i] = undefined;
-				delete maskset.tests[i];
-			}
-		}
-	}
-
-	if (typeof opts.preValidation === "function" && fromIsValid !== true && validateOnly !== true) {
-		result = opts.preValidation.call(inputmask, getBuffer.call(inputmask), maskPos, c, isSelection.call(inputmask, pos), opts, maskset, pos, strict || fromAlternate);
-		result = processCommandObject(result);
-	}
-	if (result === true) { //preValidation result
-		result = _isValid(maskPos, c, strict);
-		if ((!strict || fromIsValid === true) && result === false && validateOnly !== true) {
-			var currentPosValid = maskset.validPositions[maskPos];
-			if (currentPosValid && currentPosValid.match.static === true && (currentPosValid.match.def === c || c === opts.skipOptionalPartCharacter)) {
-				result = {
-					"caret": seekNext.call(inputmask, maskPos)
-				};
-			} else {
-				if (opts.insertMode || maskset.validPositions[seekNext.call(inputmask, maskPos)] === undefined || pos.end > maskPos) { //does the input match on a further position?
-					var skip = false;
-					if (maskset.jitOffset[maskPos] && maskset.validPositions[seekNext.call(inputmask, maskPos)] === undefined) {
-						result = isValid.call(inputmask, maskPos + maskset.jitOffset[maskPos], c, true, true);
-						if (result !== false) {
-							if (fromAlternate !== true) result.caret = maskPos;
-							skip = true;
-						}
-					}
-					if (pos.end > maskPos) {
-						maskset.validPositions[maskPos] = undefined;
-					}
-					if (!skip && !isMask.call(inputmask, maskPos, opts.keepStatic && maskPos === 0)) {
-						for (var nPos = maskPos + 1, snPos = seekNext.call(inputmask, maskPos, false, maskPos !== 0); nPos <= snPos; nPos++) {
-							// if (!isMask(nPos, true)) {
-							// 	continue;
-							// }
-							result = _isValid(nPos, c, strict);
-							if (result !== false) {
-								result = trackbackPositions.call(inputmask, maskPos, result.pos !== undefined ? result.pos : nPos) || result;
-								maskPos = nPos;
-								break;
-							}
-						}
-					}
-				}
-			}
-		}
-
-		if (result === false && opts.keepStatic && (isComplete.call(inputmask, getBuffer.call(inputmask)) || maskPos === 0) && !strict && fromAlternate !== true) { //try fuzzy alternator logic
-			result = alternate.call(inputmask, maskPos, c, strict, fromIsValid, undefined, pos);
-		} else if (isSelection.call(inputmask, pos) && maskset.tests[maskPos] && maskset.tests[maskPos].length > 1 && opts.keepStatic && !strict && fromAlternate !== true) { //selection clears an alternated keepstatic mask ~ #2189
-			result = alternate.call(inputmask, true);
-		}
-
-		if (result === true) {
-			result = {
-				"pos": maskPos
-			};
-		}
-	}
-	if (typeof opts.postValidation === "function" && fromIsValid !== true && validateOnly !== true) {
-		var postResult = opts.postValidation.call(inputmask, getBuffer.call(inputmask, true), pos.begin !== undefined ? (inputmask.isRTL ? pos.end : pos.begin) : pos, c, result, opts, maskset, strict, fromCheckval);
-		if (postResult !== undefined) {
-			result = postResult === true ? result : postResult;
-		}
-	}
-
-	if (result && result.pos === undefined) {
-		result.pos = maskPos;
-	}
-
-	if (result === false || validateOnly === true) {
-		resetMaskSet.call(inputmask, true);
-		maskset.validPositions = $.extend(true, {}, positionsClone); //revert validation changes
-	} else {
-		trackbackPositions.call(inputmask, undefined, maskPos, true);
-	}
-
-	var endResult = processCommandObject(result);
-	// console.log("returned result " + JSON.stringify(endResult));
-	if (inputmask.maxLength !== undefined) {
-		var buffer = getBuffer.call(inputmask);
-		if (buffer.length > inputmask.maxLength && !fromIsValid) {
-			resetMaskSet.call(inputmask, true);
-			maskset.validPositions = $.extend(true, {}, positionsClone); //revert validation changes
-			endResult = false;
-		}
-	}
-	return endResult;
-}
-
-//tobe put on prototype?
-function positionCanMatchDefinition(pos, testDefinition, opts) {
-	const inputmask = this,
-		maskset = this.maskset;
-
-	var valid = false,
-		tests = getTests.call(inputmask, pos);
-	for (var tndx = 0; tndx < tests.length; tndx++) {
-		if (tests[tndx].match &&
-			((tests[tndx].match["nativeDef"] === testDefinition.match[opts.shiftPositions ? "def" : "nativeDef"] && (!opts.shiftPositions || !testDefinition.match.static)) ||
-				tests[tndx].match["nativeDef"] === testDefinition.match["nativeDef"] || (opts.regex && !tests[tndx].match.static && tests[tndx].match.fn.test(testDefinition.input)))) {
-			valid = true;
-			break;
-		} else if (tests[tndx].match && tests[tndx].match["def"] === testDefinition.match["nativeDef"]) {
-			valid = undefined;
-			break;
-		}
-	}
-	if (valid === false) {
-		if (maskset.jitOffset[pos] !== undefined) {
-			valid = positionCanMatchDefinition.call(inputmask, pos + maskset.jitOffset[pos], testDefinition, opts);
-		}
-	}
-	return valid;
-}
-
-//tobe put on prototype?
-function refreshFromBuffer(start, end, buffer) {
-	const inputmask = this,
-		maskset = this.maskset,
-		opts = this.opts,
-		$ = this.dependencyLib;
-	// checkVal.call(inputmask, el, false, true, isRTL ? buffer.reverse() : buffer);
-	var i, p, skipOptionalPartCharacter = opts.skipOptionalPartCharacter,
-		bffr = inputmask.isRTL ? buffer.slice().reverse() : buffer;
-	opts.skipOptionalPartCharacter = "";
-	if (start === true) {
-		resetMaskSet.call(inputmask);
-		maskset.tests = {}; //refresh tests after possible alternating
-		start = 0;
-		end = buffer.length;
-		p = determineNewCaretPosition.call(inputmask, { begin: 0, end: 0 }, false).begin;
-	} else {
-		for (i = start; i < end; i++) {
-			delete maskset.validPositions[i];
-		}
-		p = start;
-	}
-
-	var keypress = new $.Event("keypress");
-	for (i = start; i < end; i++) {
-		keypress.keyCode = bffr[i].toString().charCodeAt(0);
-		inputmask.ignorable = false; //make sure ignorable is ignored ;-)
-		var valResult = EventHandlers.keypressEvent.call(inputmask, keypress, true, false, false, p);
-		if (valResult !== false && valResult !== undefined) {
-			p = valResult.forwardPosition;
-		}
-	}
-
-	opts.skipOptionalPartCharacter = skipOptionalPartCharacter;
-}
-
-//tobe put on prototype?
-//fill in best positions according the current input
-function trackbackPositions(originalPos, newPos, fillOnly) {
-	const inputmask = this,
-		maskset = this.maskset,
-		$ = this.dependencyLib;
-
-	// console.log("trackbackPositions " + originalPos + " " + newPos);
-	if (originalPos === undefined) {
-		//find previous valid
-		for (originalPos = newPos - 1; originalPos > 0; originalPos--) {
-			if (maskset.validPositions[originalPos]) break;
-		}
-	}
-	for (var ps = originalPos; ps < newPos; ps++) {
-		if (maskset.validPositions[ps] === undefined && !isMask.call(inputmask, ps, false)) {
-			var vp = ps == 0 ? getTest.call(inputmask, ps) : maskset.validPositions[ps - 1];
-			if (vp) {
-				var tests = getTests.call(inputmask, ps).slice();
-				if (tests[tests.length - 1].match.def === "") tests.pop();
-				var bestMatch = determineTestTemplate.call(inputmask, ps, tests), np;
-				if (bestMatch && (bestMatch.match.jit !== true || (bestMatch.match.newBlockMarker === "master" && (np = maskset.validPositions[ps + 1]) && np.match.optionalQuantifier === true))) {
-					bestMatch = $.extend({}, bestMatch, {
-						"input": getPlaceholder.call(inputmask, ps, bestMatch.match, true) || bestMatch.match.def
-					});
-					bestMatch.generatedInput = true;
-					revalidateMask.call(inputmask, ps, bestMatch, true);
-
-					if (fillOnly !== true) {
-						//revalidate the new position to update the locator value
-						var cvpInput = maskset.validPositions[newPos].input;
-						maskset.validPositions[newPos] = undefined;
-						return isValid.call(inputmask, newPos, cvpInput, true, true);
-					}
-				}
-			}
-		}
-	}
-}
-
-//tobe put on prototype?
-function revalidateMask(pos, validTest, fromIsValid, validatedPos) {
-	const inputmask = this,
-		maskset = this.maskset,
-		opts = this.opts,
-		$ = this.dependencyLib;
-
-	function IsEnclosedStatic(pos, valids, selection) {
-		var posMatch = valids[pos];
-		if (posMatch !== undefined && posMatch.match.static === true && posMatch.match.optionality !== true && (valids[0] === undefined || valids[0].alternation === undefined)) {
-			var prevMatch = selection.begin <= pos - 1 ? valids[pos - 1] && valids[pos - 1].match.static === true && valids[pos - 1] : valids[pos - 1],
-				nextMatch = selection.end > pos + 1 ? valids[pos + 1] && valids[pos + 1].match.static === true && valids[pos + 1] : valids[pos + 1];
-			return prevMatch && nextMatch;
-		}
-		return false;
-	}
-
-	var offset = 0, begin = pos.begin !== undefined ? pos.begin : pos, end = pos.end !== undefined ? pos.end : pos,
-		valid = true;
-	if (pos.begin > pos.end) {
-		begin = pos.end;
-		end = pos.begin;
-	}
-
-	validatedPos = validatedPos !== undefined ? validatedPos : begin;
-	if (begin !== end || (opts.insertMode && maskset.validPositions[validatedPos] !== undefined && fromIsValid === undefined) || validTest === undefined || validTest.match.optionalQuantifier || validTest.match.optionality) {
-		//reposition & revalidate others
-		var positionsClone = $.extend(true, {}, maskset.validPositions),
-			lvp = getLastValidPosition.call(inputmask, undefined, true),
-			i;
-		maskset.p = begin; //needed for alternated position after overtype selection
-
-		for (i = lvp; i >= begin; i--) {
-			delete maskset.validPositions[i];
-			if (validTest === undefined) delete maskset.tests[i + 1];
-		}
-
-		var j = validatedPos,
-			posMatch = j, t, canMatch, test;
-
-		if (validTest) {
-			maskset.validPositions[validatedPos] = $.extend(true, {}, validTest);
-			posMatch++;
-			j++;
-		}
-
-		for (i = validTest ? end : end - 1; i <= lvp; i++) {
-			if ((t = positionsClone[i]) !== undefined && t.generatedInput !== true &&
-				(i >= end || (i >= begin && IsEnclosedStatic(i, positionsClone, {
-					begin: begin,
-					end: end
-				})))) {
-				while (test = getTest.call(inputmask, posMatch), test.match.def !== "") { //loop needed to match further positions
-					if ((canMatch = positionCanMatchDefinition.call(inputmask, posMatch, t, opts)) !== false || t.match.def === "+") { //validated match //we still need some hackery for the + validator (numeric alias)
-						if (t.match.def === "+") getBuffer.call(inputmask, true);
-						var result = isValid.call(inputmask, posMatch, t.input, t.match.def !== "+", /*t.match.def !== "+"*/ true);
-						valid = result !== false;
-						j = (result.pos || posMatch) + 1;
-						if (!valid && canMatch) break;
-					} else {
-						valid = false;
-					}
-					if (valid) {
-						if (validTest === undefined && t.match.static && i === pos.begin) offset++;
-						break;
-					}
-					if (!valid && getBuffer.call(inputmask), posMatch > maskset.maskLength) {
-						break;
-					}
-					posMatch++;
-				}
-				if (getTest.call(inputmask, posMatch).match.def == "") {
-					valid = false;
-				}
-				//restore position
-				posMatch = j;
-			}
-			if (!valid) break;
-		}
-		if (!valid) {
-			maskset.validPositions = $.extend(true, {}, positionsClone);
-			resetMaskSet.call(inputmask, true);
-			return false;
-		}
-	} else if (validTest && getTest.call(inputmask, validatedPos).match.cd === validTest.match.cd) {
-		maskset.validPositions[validatedPos] = $.extend(true, {}, validTest);
-	}
-
-	resetMaskSet.call(inputmask, true);
-	return offset;
-}