use-mask-input 1.0.2 → 2.0.1

package/node_modules/inputmask/lib/mask.js

@@ -1,4 +1,3 @@
-import "./getPrototypeOf";
 import keyCode from "./keycode.json";
 import {caret, getBuffer, getBufferTemplate, getLastValidPosition, resetMaskSet, seekNext} from "./positioning";
 import {applyInputValue, clearOptionalTail, writeBuffer} from "./inputHandling";
@@ -61,7 +60,7 @@ function mask() {
 					return this.inputmask.opts.autoUnmask ?
 						this.inputmask.unmaskedvalue() :
 						(getLastValidPosition.call(inputmask) !== -1 || opts.nullable !== true ?
-							((this.inputmask.shadowRoot || document.activeElement) === this && opts.clearMaskOnLostFocus ?
+							(((this.inputmask.shadowRoot || this.ownerDocument).activeElement) === this && opts.clearMaskOnLostFocus ?
 								(inputmask.isRTL ? clearOptionalTail.call(inputmask,getBuffer.call(inputmask).slice()).reverse() : clearOptionalTail.call(inputmask,getBuffer.call(inputmask).slice())).join("") :
 								valueGet.call(this)) :
 							"");
@@ -216,8 +215,9 @@ function mask() {
 		EventRuler.on(el, "setvalue", EventHandlers.setValueEvent);
 
 		//apply mask
-		inputmask.undoValue = getBufferTemplate.call(inputmask).join(""); //initialize the buffer and getmasklength
-		var activeElement = (el.inputmask.shadowRoot || document).activeElement;
+		getBufferTemplate.call(inputmask).join(""); //initialize the buffer and getmasklength
+		inputmask.undoValue = inputmask._valueGet(true);
+		var activeElement = (el.inputmask.shadowRoot || el.ownerDocument).activeElement;
 		if (el.inputmask._valueGet(true) !== "" || opts.clearMaskOnLostFocus === false || activeElement === el) {
 			applyInputValue(el, el.inputmask._valueGet(true), opts);
 			var buffer = getBuffer.call(inputmask).slice();

package/node_modules/inputmask/lib/masktoken.js

@@ -0,0 +1,13 @@
+export default function (isGroup, isOptional, isQuantifier, isAlternator) {
+	this.matches = [];
+	this.openGroup = isGroup || false;
+	this.alternatorGroup = false;
+	this.isGroup = isGroup || false;
+	this.isOptional = isOptional || false;
+	this.isQuantifier = isQuantifier || false;
+	this.isAlternator = isAlternator || false;
+	this.quantifier = {
+		min: 1,
+		max: 1
+	};
+}

package/node_modules/inputmask/lib/polyfills/Array.includes.js

@@ -0,0 +1,48 @@
+// https://tc39.github.io/ecma262/#sec-array.prototype.includes
+if (!Array.prototype.includes) {
+	Object.defineProperty(Array.prototype, "includes", {
+		value: function(searchElement, fromIndex) {
+
+			// 1. Let O be ? ToObject(this value).
+			if (this == null) {
+				throw new TypeError("\"this\" is null or not defined");
+			}
+
+			var o = Object(this);
+
+			// 2. Let len be ? ToLength(? Get(O, "length")).
+			var len = o.length >>> 0;
+
+			// 3. If len is 0, return false.
+			if (len === 0) {
+				return false;
+			}
+
+			// 4. Let n be ? ToInteger(fromIndex).
+			//    (If fromIndex is undefined, this step produces the value 0.)
+			var n = fromIndex | 0;
+
+			// 5. If n ≥ 0, then
+			//  a. Let k be n.
+			// 6. Else n < 0,
+			//  a. Let k be len + n.
+			//  b. If k < 0, let k be 0.
+			var k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);
+
+			// 7. Repeat, while k < len
+			while (k < len) {
+				// a. Let elementK be the result of ? Get(O, ! ToString(k)).
+				// b. If SameValueZero(searchElement, elementK) is true, return true.
+				// c. Increase k by 1.
+				// NOTE: === provides the correct "SameValueZero" comparison needed here.
+				if (o[k] === searchElement) {
+					return true;
+				}
+				k++;
+			}
+
+			// 8. Return false
+			return false;
+		}
+	});
+}

package/node_modules/inputmask/lib/positioning.js

@@ -7,7 +7,6 @@ import {
 	getTestTemplate
 } from "./validation-tests";
 import {checkAlternationMatch} from "./validation";
-import {mask} from "./mask";
 
 export {
 	caret,
@@ -54,7 +53,7 @@ function caret(input, begin, end, notranslate, isDelete) {
 					end++; //set visualization for insert/overwrite mode
 				}
 			}
-			if (input === (input.inputmask.shadowRoot || document).activeElement) {
+			if (input === (input.inputmask.shadowRoot || input.ownerDocument).activeElement) {
 				if ("setSelectionRange" in input) {
 					input.setSelectionRange(begin, end);
 				} else if (window.getSelection) {
@@ -152,7 +151,7 @@ function determineLastRequiredPosition(returnDefinition) {
 }
 
 //tobe put on prototype?
-function determineNewCaretPosition(selectedCaret, tabbed) {
+function determineNewCaretPosition(selectedCaret, tabbed, positionCaretOnClick) {
 	const inputmask = this,
 		maskset = this.maskset,
 		opts = this.opts;
@@ -184,7 +183,8 @@ function determineNewCaretPosition(selectedCaret, tabbed) {
 		}
 	}
 	if (selectedCaret.begin === selectedCaret.end) {
-		switch (opts.positionCaretOnClick) {
+		positionCaretOnClick = positionCaretOnClick || opts.positionCaretOnClick;
+		switch (positionCaretOnClick) {
 			case "none":
 				break;
 			case "select":
@@ -342,7 +342,7 @@ function translatePosition(pos) {
 		el = this.el;
 
 	if (inputmask.isRTL && typeof pos === "number" && (!opts.greedy || opts.placeholder !== "") && el) {
-		pos = inputmask._valueGet().length - pos;
+		pos = Math.abs(inputmask._valueGet().length - pos);
 	}
 	return pos;
 }

package/node_modules/inputmask/lib/validation-tests.js

@@ -1,4 +1,14 @@
-export {determineTestTemplate, getDecisionTaker, getMaskTemplate, getPlaceholder, getTest, getTests, getTestTemplate};
+export {
+	determineTestTemplate,
+	getDecisionTaker,
+	getMaskTemplate,
+	getPlaceholder,
+	getTest,
+	getTests,
+	getTestTemplate,
+	isSubsetOf
+};
+import Inputmask from "./inputmask";
 
 function getLocator(tst, align) { //need to align the locators to be correct
 	var locator = (tst.alternation != undefined ? tst.mloc[getDecisionTaker(tst)] : tst.locator).join("");
@@ -59,14 +69,17 @@ function getMaskTemplate(baseOnInput, minimalPos, includeMode, noJit, clearOptio
 
 
 	var greedy = opts.greedy;
-	if (clearOptionalTail) opts.greedy = false;
+	if (clearOptionalTail && opts.greedy) {
+		opts.greedy = false;
+		inputmask.maskset.tests = {};
+	}
 	minimalPos = minimalPos || 0;
 	var maskTemplate = [],
 		ndxIntlzr, pos = 0,
 		test, testPos, jitRenderStatic;
 	do {
 		if (baseOnInput === true && maskset.validPositions[pos]) {
-			testPos = (clearOptionalTail && maskset.validPositions[pos].match.optionality === true
+			testPos = (clearOptionalTail && maskset.validPositions[pos].match.optionality
 				&& maskset.validPositions[pos + 1] === undefined
 				&& (maskset.validPositions[pos].generatedInput === true || (maskset.validPositions[pos].input == opts.skipOptionalPartCharacter && pos > 0)))
 				? determineTestTemplate.call(inputmask, pos, getTests.call(inputmask, pos, ndxIntlzr, pos - 1))
@@ -80,7 +93,7 @@ function getMaskTemplate(baseOnInput, minimalPos, includeMode, noJit, clearOptio
 			ndxIntlzr = testPos.locator.slice();
 			var jitMasking = noJit === true ? false : (opts.jitMasking !== false ? opts.jitMasking : test.jit);
 			//check for groupSeparator is a hack for the numerics as we don't want the render of the groupSeparator beforehand
-			jitRenderStatic = (jitRenderStatic && test.static && test.def !== opts.groupSeparator && test.fn === null) || (maskset.validPositions[pos - 1] && test.static && test.def !== opts.groupSeparator && test.fn === null);
+			jitRenderStatic = ((jitRenderStatic && test.static && test.def !== opts.groupSeparator && test.fn === null) || (maskset.validPositions[pos - 1] && test.static && test.def !== opts.groupSeparator && test.fn === null)) && maskset.tests[pos] && maskset.tests[pos].length === 1;
 			if (jitRenderStatic || jitMasking === false || jitMasking === undefined /*|| pos < lvp*/ || (typeof jitMasking === "number" && isFinite(jitMasking) && jitMasking > pos)) {
 				maskTemplate.push(includeMode === false ? test.nativeDef : getPlaceholder.call(inputmask, pos, test));
 			} else {
@@ -89,7 +102,7 @@ function getMaskTemplate(baseOnInput, minimalPos, includeMode, noJit, clearOptio
 		}
 
 		pos++;
-	} while ((inputmask.maxLength === undefined || pos < inputmask.maxLength) && (test.static !== true || test.def !== "") || minimalPos > pos);
+	} while ((test.static !== true || test.def !== "") || minimalPos > pos);
 	if (maskTemplate[maskTemplate.length - 1] === "") {
 		maskTemplate.pop(); //drop the last one which is empty
 	}
@@ -115,25 +128,51 @@ function getTestTemplate(pos, ndxIntlzr, tstPs) {
 function determineTestTemplate(pos, tests) {
 	var inputmask = this,
 		opts = this.opts;
-
+	var optionalityLevel = determineOptionalityLevel(pos, tests);
 	pos = pos > 0 ? pos - 1 : 0;
 	var altTest = getTest.call(inputmask, pos), targetLocator = getLocator(altTest), tstLocator, closest, bestMatch;
+	if (opts.greedy && tests.length > 1 && tests[tests.length - 1].match.def === "")
+		tests.pop();
+	// console.log(" optionality = " + optionalityLevel);
+	// console.log(" - " + JSON.stringify(tests));
 	for (var ndx = 0; ndx < tests.length; ndx++) { //find best matching
 		var tst = tests[ndx];
 		tstLocator = getLocator(tst, targetLocator.length);
 		var distance = Math.abs(tstLocator - targetLocator);
+
 		if (closest === undefined
 			|| (tstLocator !== "" && distance < closest)
-			|| (bestMatch && !opts.greedy && bestMatch.match.optionality && bestMatch.match.newBlockMarker === "master" && (!tst.match.optionality || !tst.match.newBlockMarker))
-			|| (bestMatch && bestMatch.match.optionalQuantifier && !tst.match.optionalQuantifier)) {
+			|| (bestMatch && !opts.greedy &&
+				(bestMatch.match.optionality && bestMatch.match.optionality - optionalityLevel > 0) &&
+				bestMatch.match.newBlockMarker === "master" &&
+				((!tst.match.optionality || tst.match.optionality - optionalityLevel < 1) || !tst.match.newBlockMarker))
+			|| (bestMatch && !opts.greedy && bestMatch.match.optionalQuantifier && !tst.match.optionalQuantifier)) {
 			closest = distance;
 			bestMatch = tst;
 		}
 	}
-
 	return bestMatch;
 }
 
+function determineOptionalityLevel(pos, tests) {
+	let optionalityLevel = 0, differentOptionalLevels = false;
+	tests.forEach(test => {
+		if (test.match.optionality) {
+			if (optionalityLevel !== 0 && optionalityLevel !== test.match.optionality)
+				differentOptionalLevels = true;
+			if (optionalityLevel === 0 || optionalityLevel > test.match.optionality) {
+				optionalityLevel = test.match.optionality;
+			}
+		}
+	});
+	if (optionalityLevel) {
+		if (pos == 0) optionalityLevel = 0;
+		else if (tests.length == 1) optionalityLevel = 0;
+		else if (!differentOptionalLevels) optionalityLevel = 0;
+	}
+	return optionalityLevel;
+}
+
 //tobe put on prototype?
 function getTest(pos, tests) {
 	var inputmask = this,
@@ -145,6 +184,28 @@ function getTest(pos, tests) {
 	return (tests || getTests.call(inputmask, pos))[0];
 }
 
+function isSubsetOf(source, target, opts) {
+	function expand(pattern) {
+		var expanded = [], start = -1, end;
+		for (var i = 0, l = pattern.length; i < l; i++) {
+			if (pattern.charAt(i) === "-") {
+				end = pattern.charCodeAt(i + 1);
+				while (++start < end) expanded.push(String.fromCharCode(start));
+			} else {
+				start = pattern.charCodeAt(i);
+				expanded.push(pattern.charAt(i));
+			}
+		}
+		return expanded.join("");
+	}
+
+	if (source.match.def === target.match.nativeDef) return true;
+	if ((opts.regex || (source.match.fn instanceof RegExp && target.match.fn instanceof RegExp)) && source.match.static !== true && target.match.static !== true) { //is regex a subset
+		return expand(target.match.fn.toString().replace(/[[\]/]/g, "")).indexOf(expand(source.match.fn.toString().replace(/[[\]/]/g, ""))) !== -1;
+	}
+	return false;
+}
+
 //tobe put on prototype?
 function getTests(pos, ndxIntlzr, tstPs) {
 	var inputmask = this,
@@ -205,28 +266,6 @@ function getTests(pos, ndxIntlzr, tstPs) {
 				}
 			}
 
-			function isSubsetOf(source, target) {
-				function expand(pattern) {
-					var expanded = [], start = -1, end;
-					for (var i = 0, l = pattern.length; i < l; i++) {
-						if (pattern.charAt(i) === "-") {
-							end = pattern.charCodeAt(i + 1);
-							while (++start < end) expanded.push(String.fromCharCode(start));
-						} else {
-							start = pattern.charCodeAt(i);
-							expanded.push(pattern.charAt(i));
-						}
-					}
-					return expanded.join("");
-				}
-
-				if (source.match.def === target.match.nativeDef) return true;
-				if ((opts.regex || (source.match.fn instanceof RegExp && target.match.fn instanceof RegExp)) && source.match.static !== true && target.match.static !== true) { //is regex a subset
-					return expand(target.match.fn.toString().replace(/[[\]/]/g, "")).indexOf(expand(source.match.fn.toString().replace(/[[\]/]/g, ""))) !== -1;
-				}
-				return false;
-			}
-
 			function staticCanMatchDefinition(source, target) {
 				return source.match.static === true && target.match.static !== true ? target.match.fn.test(source.match.def, maskset, pos, false, opts, false) : false;
 			}
@@ -289,7 +328,14 @@ function getTests(pos, ndxIntlzr, tstPs) {
 					"cd": cacheDependency,
 					"mloc": {}
 				});
-				return true;
+				if (match.optionality && quantifierRecurse === undefined &&
+					((opts.definitions && opts.definitions[match.nativeDef] && opts.definitions[match.nativeDef].optional) ||
+						(Inputmask.prototype.definitions[match.nativeDef] && Inputmask.prototype.definitions[match.nativeDef].optional))) { //prevent loop see #698
+					insertStop = true; //insert a stop
+					testPos = pos; //match the position after the group
+				} else {
+					return true;
+				}
 			} else if (match.matches !== undefined) {
 				if (match.isGroup && quantifierRecurse !== match) { //when a group pass along to the quantifier
 					match = handleMatch(maskToken.matches[maskToken.matches.indexOf(match) + 1], loopNdx, quantifierRecurse);
@@ -301,10 +347,11 @@ function getTests(pos, ndxIntlzr, tstPs) {
 						//mark optionality in matches
 						matches.forEach(function (mtch, ndx) {
 							if (ndx >= mtchsNdx) {
-								mtch.match.optionality = true;
+								mtch.match.optionality = mtch.match.optionality ? mtch.match.optionality + 1 : 1;
 							}
 						});
 						latestMatch = matches[matches.length - 1].match;
+
 						if (quantifierRecurse === undefined && isFirstMatch(latestMatch, optionalToken)) { //prevent loop see #698
 							insertStop = true; //insert a stop
 							testPos = pos; //match the position after the group
@@ -317,7 +364,8 @@ function getTests(pos, ndxIntlzr, tstPs) {
 						malternateMatches = [],
 						maltMatches,
 						currentMatches = matches.slice(),
-						loopNdxCnt = loopNdx.length;
+						loopNdxCnt = loopNdx.length,
+						unMatchedAlternation = false;
 					var altIndex = ndxInitializer.length > 0 ? ndxInitializer.shift() : -1;
 					if (altIndex === -1 || typeof altIndex === "string") {
 						var currentPos = testPos,
@@ -346,16 +394,21 @@ function getTests(pos, ndxIntlzr, tstPs) {
 							}
 						}
 						if (opts.keepStatic === true || (isFinite(parseInt(opts.keepStatic)) && currentPos >= opts.keepStatic)) altIndexArr = altIndexArr.slice(0, 1);
-						var unMatchedAlternation = false;
 						for (var ndx = 0; ndx < altIndexArr.length; ndx++) {
 							amndx = parseInt(altIndexArr[ndx]);
 							matches = [];
 							//set the correct ndxInitializer
 							ndxInitializer = typeof altIndex === "string" ? resolveNdxInitializer(testPos, amndx, loopNdxCnt) || ndxInitializerClone.slice() : ndxInitializerClone.slice();
-							if (alternateToken.matches[amndx] && handleMatch(alternateToken.matches[amndx], [amndx].concat(loopNdx), quantifierRecurse)) {
+							var tokenMatch = alternateToken.matches[amndx];
+							if (tokenMatch && handleMatch(tokenMatch, [amndx].concat(loopNdx), quantifierRecurse)) {
 								match = true;
-							} else if (ndx === 0) {
-								unMatchedAlternation = true;
+							} else {
+								if (ndx === 0) {
+									unMatchedAlternation = true;
+								}
+								if (tokenMatch && tokenMatch.matches && tokenMatch.matches.length > alternateToken.matches[0].matches.length) {
+									break;
+								}
 							}
 
 							maltMatches = matches.slice();
@@ -376,13 +429,13 @@ function getTests(pos, ndxIntlzr, tstPs) {
 											dropMatch = true;
 											setMergeLocators(altMatch2, altMatch);
 											break;
-										} else if (isSubsetOf(altMatch, altMatch2)) {
+										} else if (isSubsetOf(altMatch, altMatch2, opts)) {
 											if (setMergeLocators(altMatch, altMatch2)) {
 												dropMatch = true;
 												malternateMatches.splice(malternateMatches.indexOf(altMatch2), 0, altMatch);
 											}
 											break;
-										} else if (isSubsetOf(altMatch2, altMatch)) {
+										} else if (isSubsetOf(altMatch2, altMatch, opts)) {
 											setMergeLocators(altMatch2, altMatch);
 											break;
 										} else if (staticCanMatchDefinition(altMatch, altMatch2)) {
@@ -426,7 +479,8 @@ function getTests(pos, ndxIntlzr, tstPs) {
 							//TODO FIX RECURSIVE QUANTIFIERS
 							latestMatch.optionalQuantifier = qndx >= qt.quantifier.min;
 							// console.log(pos + " " + qt.quantifier.min + " " + latestMatch.optionalQuantifier);
-							latestMatch.jit = (qndx || 1) * tokenGroup.matches.indexOf(latestMatch) >= qt.quantifier.jit;
+							//qndx + 1 as the index starts from 0
+							latestMatch.jit = (qndx + 1) * (tokenGroup.matches.indexOf(latestMatch) + 1) > qt.quantifier.jit;
 							if (latestMatch.optionalQuantifier && isFirstMatch(latestMatch, tokenGroup)) {
 								insertStop = true;
 								testPos = pos; //match the position after the group
@@ -487,7 +541,7 @@ function getTests(pos, ndxIntlzr, tstPs) {
 		return locator;
 	}
 
-	if (pos > -1 && (inputmask.maxLength === undefined || pos < inputmask.maxLength)) {
+	if (pos > -1) {
 		if (ndxIntlzr === undefined) { //determine index initializer
 			var previousPos = pos - 1,
 				test;
@@ -525,11 +579,19 @@ function getTests(pos, ndxIntlzr, tstPs) {
 			cd: cacheDependency
 		});
 	}
-
+	var result;
 	if (ndxIntlzr !== undefined && maskset.tests[pos]) { //prioritize full tests for caching
-		return $.extend(true, [], matches);
+		result = $.extend(true, [], matches);
+	} else {
+		maskset.tests[pos] = $.extend(true, [], matches); //set a clone to prevent overwriting some props
+		result = maskset.tests[pos];
 	}
-	maskset.tests[pos] = $.extend(true, [], matches); //set a clone to prevent overwriting some props
+
 	// console.log(pos + " - " + JSON.stringify(matches));
-	return maskset.tests[pos];
+	//cleanup optionality marking
+	matches.forEach(t => {
+		t.match.optionality = false;
+	});
+
+	return result;
 }