use-mask-input 1.0.1 → 2.0.0

package/node_modules/inputmask/lib/global/window.js

@@ -1,7 +1,3 @@
-if (typeof define === "function" && define.amd)
-	define(function () {
-		return typeof window !== "undefined" ? window : new (eval("require('jsdom').JSDOM"))("").window;
-	});
-else if (typeof exports === "object")
-	module.exports = typeof window !== "undefined" ? window : new (eval("require('jsdom').JSDOM"))("").window;
+import canUseDOM from "../canUseDOM";
 
+export default canUseDOM ? window : {};

package/node_modules/inputmask/lib/inputHandling.js

@@ -0,0 +1,252 @@
+import keyCode from "./keycode.json";
+import {getMaskTemplate, getPlaceholder, getTest} from "./validation-tests";
+import {
+	caret,
+	determineNewCaretPosition,
+	getBuffer, getBufferTemplate,
+	getLastValidPosition,
+	isMask,
+	resetMaskSet,
+	seekNext
+} from "./positioning";
+import {isComplete, refreshFromBuffer} from "./validation";
+import {ie} from "./environment";
+import {EventHandlers} from "./eventhandlers";
+
+
+export {applyInputValue, clearOptionalTail, checkVal, HandleNativePlaceholder, unmaskedvalue, writeBuffer};
+
+function applyInputValue(input, value) {
+	const inputmask = input ? input.inputmask : this, opts = inputmask.opts;
+
+	input.inputmask.refreshValue = false;
+	if (typeof opts.onBeforeMask === "function") value = opts.onBeforeMask.call(inputmask, value, opts) || value;
+	value = value.toString().split("");
+	checkVal(input, true, false, value);
+	inputmask.undoValue = inputmask._valueGet(true);
+	if ((opts.clearMaskOnLostFocus || opts.clearIncomplete) && input.inputmask._valueGet() === getBufferTemplate.call(inputmask).join("") && getLastValidPosition.call(inputmask) === -1) {
+		input.inputmask._valueSet("");
+	}
+}
+
+//todo put on prototype?
+function clearOptionalTail(buffer) {
+	const inputmask = this;
+
+	buffer.length = 0;
+	var template = getMaskTemplate.call(inputmask, true, 0, true, undefined, true), lmnt;
+	while ((lmnt = template.shift()) !== undefined) buffer.push(lmnt);
+	return buffer;
+}
+
+function checkVal(input, writeOut, strict, nptvl, initiatingEvent) {
+	const inputmask = input ? input.inputmask : this,
+		maskset = inputmask.maskset,
+		opts = inputmask.opts, $ = inputmask.dependencyLib;
+
+	var inputValue = nptvl.slice(),
+		charCodes = "",
+		initialNdx = -1,
+		result = undefined, skipOptionalPartCharacter = opts.skipOptionalPartCharacter;
+	opts.skipOptionalPartCharacter = ""; //see issue #2311
+
+	function isTemplateMatch(ndx, charCodes) {
+		var targetTemplate = getMaskTemplate.call(inputmask, true, 0).slice(ndx, seekNext.call(inputmask, ndx, false, false)).join("").replace(/'/g, ""),
+			charCodeNdx = targetTemplate.indexOf(charCodes);
+		//strip spaces from targetTemplate
+		while (charCodeNdx > 0 && targetTemplate[charCodeNdx - 1] === " ") charCodeNdx--;
+
+		var match = charCodeNdx === 0 && !isMask.call(inputmask, ndx)
+			&& (getTest.call(inputmask, ndx).match.nativeDef === charCodes.charAt(0)
+				|| (getTest.call(inputmask, ndx).match.static === true && getTest.call(inputmask, ndx).match.nativeDef === ("'" + charCodes.charAt(0)))
+				|| (getTest.call(inputmask, ndx).match.nativeDef === " " && (getTest.call(inputmask, ndx + 1).match.nativeDef === charCodes.charAt(0)
+					|| (getTest.call(inputmask, ndx + 1).match.static === true && getTest.call(inputmask, ndx + 1).match.nativeDef === ("'" + charCodes.charAt(0))))));
+
+		if (!match && charCodeNdx > 0 && !isMask.call(inputmask, ndx, false, true)) {
+			var nextPos = seekNext.call(inputmask, ndx);
+			if (inputmask.caretPos.begin < nextPos) {
+				inputmask.caretPos = {begin: nextPos};
+			}
+		}
+		return match;
+	}
+
+	resetMaskSet.call(inputmask);
+	maskset.tests = {}; //reset tests ~ possible after alternating
+	initialNdx = opts.radixPoint ? determineNewCaretPosition.call(inputmask, {
+		begin: 0,
+		end: 0
+	}, false, opts.__financeInput === false ? "radixFocus" : undefined).begin : 0;
+	maskset.p = initialNdx;
+	inputmask.caretPos = {begin: initialNdx};
+
+	var staticMatches = [], prevCaretPos = inputmask.caretPos;
+	inputValue.forEach(function (charCode, ndx) {
+		if (charCode !== undefined) { //inputfallback strips some elements out of the inputarray.  $.each logically presents them as undefined
+			/*if (maskset.validPositions[ndx] === undefined && inputValue[ndx] === getPlaceholder.call(inputmask, ndx) && isMask.call(inputmask, ndx, true) &&
+				isValid.call(inputmask, ndx, inputValue[ndx], true, undefined, true, true) === false) {
+				inputmask.caretPos.begin++;
+			} else*/
+			{
+				var keypress = new $.Event("_checkval");
+				keypress.keyCode = charCode.toString().charCodeAt(0);
+				charCodes += charCode;
+				var lvp = getLastValidPosition.call(inputmask, undefined, true);
+				if (!isTemplateMatch(initialNdx, charCodes)) {
+					result = EventHandlers.keypressEvent.call(inputmask, keypress, true, false, strict, inputmask.caretPos.begin);
+
+					if (result) {
+						initialNdx = inputmask.caretPos.begin + 1;
+						charCodes = "";
+					}
+				} else {
+					result = EventHandlers.keypressEvent.call(inputmask, keypress, true, false, strict, lvp + 1);
+				}
+				if (result) {
+					if (result.pos !== undefined && maskset.validPositions[result.pos] && maskset.validPositions[result.pos].match.static === true && maskset.validPositions[result.pos].alternation === undefined) {
+						staticMatches.push(result.pos);
+						if (!inputmask.isRTL) {
+							result.forwardPosition = result.pos + 1;
+						}
+					}
+					writeBuffer.call(inputmask, undefined, getBuffer.call(inputmask), result.forwardPosition, keypress, false);
+					inputmask.caretPos = {begin: result.forwardPosition, end: result.forwardPosition};
+					prevCaretPos = inputmask.caretPos;
+				} else {
+					if (maskset.validPositions[ndx] === undefined && inputValue[ndx] === getPlaceholder.call(inputmask, ndx) && isMask.call(inputmask, ndx, true)) {
+						inputmask.caretPos.begin++;
+					} else inputmask.caretPos = prevCaretPos; //restore the caret position from before the failed validation
+				}
+			}
+		}
+	});
+	if (staticMatches.length > 0) {
+		var sndx, validPos, nextValid = seekNext.call(inputmask, -1, undefined, false);
+		if ((!isComplete.call(inputmask, getBuffer.call(inputmask)) && staticMatches.length <= nextValid)
+			|| (isComplete.call(inputmask, getBuffer.call(inputmask)) && staticMatches.length > 0 && (staticMatches.length !== nextValid && staticMatches[0] === 0))) { //should check if is sequence starting from 0
+			var nextSndx = nextValid;
+			while ((sndx = staticMatches.shift()) !== undefined) {
+				var keypress = new $.Event("_checkval");
+				validPos = maskset.validPositions[sndx];
+				validPos.generatedInput = true;
+				keypress.keyCode = validPos.input.charCodeAt(0);
+				result = EventHandlers.keypressEvent.call(inputmask, keypress, true, false, strict, nextSndx);
+				if (result && result.pos !== undefined && result.pos !== sndx && maskset.validPositions[result.pos] && maskset.validPositions[result.pos].match.static === true) {
+					staticMatches.push(result.pos);
+				} else if (!result) break;
+				nextSndx++;
+			}
+		} else { //mark al statics as generated
+			// while ((sndx = staticMatches.pop())) {
+			// 	validPos = maskset.validPositions[sndx];
+			// 	if (validPos) {
+			// 		validPos.generatedInput = true;
+			// 	}
+			// }
+		}
+	}
+	if (writeOut) {
+		writeBuffer.call(
+			inputmask,
+			input,
+			getBuffer.call(inputmask), result ? result.forwardPosition : inputmask.caretPos.begin,
+			initiatingEvent || new $.Event("checkval"),
+			initiatingEvent && ((initiatingEvent.type === "input" && inputmask.undoValue !== getBuffer.call(inputmask).join("")) || initiatingEvent.type === "paste"));
+		// for (var vndx in maskset.validPositions) {
+		// 	if (maskset.validPositions[vndx].match.generated !== true) { //only remove non forced generated
+		// 		delete maskset.validPositions[vndx].generatedInput; //clear generated markings ~ consider initializing with a  value as fully typed
+		// 	}
+		// }
+	}
+	opts.skipOptionalPartCharacter = skipOptionalPartCharacter;
+}
+
+function HandleNativePlaceholder(npt, value) {
+	const inputmask = npt ? npt.inputmask : this;
+
+	if (ie) {
+		if (npt.inputmask._valueGet() !== value && (npt.placeholder !== value || npt.placeholder === "")) {
+			var buffer = getBuffer.call(inputmask).slice(),
+				nptValue = npt.inputmask._valueGet();
+			if (nptValue !== value) {
+				var lvp = getLastValidPosition.call(inputmask);
+				if (lvp === -1 && nptValue === getBufferTemplate.call(inputmask).join("")) {
+					buffer = [];
+				} else if (lvp !== -1) { //clearout optional tail of the mask
+					clearOptionalTail.call(inputmask, buffer);
+				}
+				writeBuffer(npt, buffer);
+			}
+		}
+	} else if (npt.placeholder !== value) {
+		npt.placeholder = value;
+		if (npt.placeholder === "") npt.removeAttribute("placeholder");
+	}
+}
+
+function unmaskedvalue(input) {
+	const inputmask = input ? input.inputmask : this,
+		opts = inputmask.opts,
+		maskset = inputmask.maskset;
+
+	if (input) {
+		if (input.inputmask === undefined) {
+			return input.value;
+		}
+		if (input.inputmask && input.inputmask.refreshValue) { //forced refresh from the value form.reset
+			applyInputValue(input, input.inputmask._valueGet(true));
+		}
+	}
+	var umValue = [],
+		vps = maskset.validPositions;
+	for (var pndx in vps) {
+		if (vps[pndx] && vps[pndx].match && (vps[pndx].match.static != true || (Array.isArray(maskset.metadata) && vps[pndx].generatedInput !== true))) {
+			//only include generated input with multiple masks (check on metadata)
+			umValue.push(vps[pndx].input);
+		}
+	}
+	var unmaskedValue = umValue.length === 0 ? "" : (inputmask.isRTL ? umValue.reverse() : umValue).join("");
+	if (typeof opts.onUnMask === "function") {
+		var bufferValue = (inputmask.isRTL ? getBuffer.call(inputmask).slice().reverse() : getBuffer.call(inputmask)).join("");
+		unmaskedValue = opts.onUnMask.call(inputmask, bufferValue, unmaskedValue, opts);
+	}
+	return unmaskedValue;
+}
+
+function writeBuffer(input, buffer, caretPos, event, triggerEvents) {
+	const inputmask = input ? input.inputmask : this,
+		opts = inputmask.opts,
+		$ = inputmask.dependencyLib;
+
+	if (event && typeof opts.onBeforeWrite === "function") {
+		//    buffer = buffer.slice(); //prevent uncontrolled manipulation of the internal buffer
+		var result = opts.onBeforeWrite.call(inputmask, event, buffer, caretPos, opts);
+		if (result) {
+			if (result.refreshFromBuffer) {
+				var refresh = result.refreshFromBuffer;
+				refreshFromBuffer.call(inputmask, refresh === true ? refresh : refresh.start, refresh.end, result.buffer || buffer);
+				buffer = getBuffer.call(inputmask, true);
+			}
+			if (caretPos !== undefined) caretPos = result.caret !== undefined ? result.caret : caretPos;
+		}
+	}
+	if (input !== undefined) {
+		input.inputmask._valueSet(buffer.join(""));
+		if (caretPos !== undefined && (event === undefined || event.type !== "blur")) {
+			// console.log(caretPos);
+			caret.call(inputmask, input, caretPos, undefined, undefined, (event !== undefined && event.type === "keydown" && (event.keyCode === keyCode.DELETE || event.keyCode === keyCode.BACKSPACE)));
+		}
+		if (triggerEvents === true) {
+			var $input = $(input), nptVal = input.inputmask._valueGet();
+			input.inputmask.skipInputEvent = true;
+			$input.trigger("input");
+			setTimeout(function () { //timeout needed for IE
+				if (nptVal === getBufferTemplate.call(inputmask).join("")) {
+					$input.trigger("cleared");
+				} else if (isComplete.call(inputmask, buffer) === true) {
+					$input.trigger("complete");
+				}
+			}, 0);
+		}
+	}
+}

package/node_modules/inputmask/lib/inputmask.js

@@ -4,27 +4,42 @@
  * Copyright (c) Robin Herbots
  * Licensed under the MIT license
  */
-var $ = require("./dependencyLibs/inputmask.dependencyLib"), window = require("./global/window"),
-	document = window.document,
-	generateMaskSet = require("./maskset").generateMaskSet,
-	analyseMask = require("./maskset").analyseMask,
-	maskScope = require("./maskScope");
+import "./polyfills/Object.getPrototypeOf";
+import "./polyfills/Array.includes";
 
+import {mask} from "./mask";
+import $ from "./dependencyLibs/inputmask.dependencyLib";
+import window from "./global/window";
+import {generateMaskSet, analyseMask} from "./mask-lexer";
+import {getMaskTemplate} from "./validation-tests";
+import {determineLastRequiredPosition, getBuffer, getBufferTemplate, isMask} from "./positioning";
+import {isComplete} from "./validation";
+import {checkVal, unmaskedvalue} from "./inputHandling";
+import {EventRuler} from "./eventruler";
+import definitions from "./definitions";
+import defaults from "./defaults";
+import canUseDOM from "./canUseDOM";
+
+const document = window.document, dataKey = "_inputmask_opts";
 
 function Inputmask(alias, options, internal) {
+	if (!canUseDOM) {
+		return;
+	}
+	
 	//allow instanciating without new
 	if (!(this instanceof Inputmask)) {
 		return new Inputmask(alias, options, internal);
 	}
 
+	this.dependencyLib = $;
 	this.el = undefined;
 	this.events = {};
 	this.maskset = undefined;
-	this.refreshValue = false; //indicate a refresh from the inputvalue is needed (form.reset)
 
 	if (internal !== true) {
 		//init options
-		if ($.isPlainObject(alias)) {
+		if (Object.prototype.toString.call(alias) === "[object Object]") {
 			options = alias;
 		} else {
 			options = options || {};
@@ -34,96 +49,39 @@ function Inputmask(alias, options, internal) {
 		this.noMasksCache = options && options.definitions !== undefined;
 		this.userOptions = options || {}; //user passed options
 		resolveAlias(this.opts.alias, options, this.opts);
-		this.isRTL = this.opts.numericInput;
 	}
+
+	//maskscope properties
+	this.refreshValue = false; //indicate a refresh from the inputvalue is needed (form.reset)
+	this.undoValue = undefined;
+	this.$el = undefined;
+	this.skipKeyPressEvent = false; //Safari 5.1.x - modal dialog fires keypress twice workaround
+	this.skipInputEvent = false; //skip when triggered from within inputmask
+	this.validationEvent = false;
+	this.ignorable = false;
+	this.maxLength;
+	this.mouseEnter = false;
+	this.originalPlaceholder = undefined; //needed for FF
+	this.isComposing = false; //keydowncode == 229  compositionevent fallback
 }
 
 Inputmask.prototype = {
 	dataAttribute: "data-inputmask", //data attribute prefix used for attribute binding
 	//options default
-	defaults: {
-		_maxTestPos: 500,
-		placeholder: "_",
-		optionalmarker: ["[", "]"],
-		quantifiermarker: ["{", "}"],
-		groupmarker: ["(", ")"],
-		alternatormarker: "|",
-		escapeChar: "\\",
-		mask: null, //needs tobe null instead of undefined as the extend method does not consider props with the undefined value
-		regex: null, //regular expression as a mask
-		oncomplete: $.noop, //executes when the mask is complete
-		onincomplete: $.noop, //executes when the mask is incomplete and focus is lost
-		oncleared: $.noop, //executes when the mask is cleared
-		repeat: 0, //repetitions of the mask: * ~ forever, otherwise specify an integer
-		greedy: false, //true: allocated buffer for the mask and repetitions - false: allocate only if needed
-		autoUnmask: false, //automatically unmask when retrieving the value with $.fn.val or value if the browser supports __lookupGetter__ or getOwnPropertyDescriptor
-		removeMaskOnSubmit: false, //remove the mask before submitting the form.
-		clearMaskOnLostFocus: true,
-		insertMode: true, //insert the input or overwrite the input
-		insertModeVisual: true, //show selected caret when insertmode = false
-		clearIncomplete: false, //clear the incomplete input on blur
-		alias: null,
-		onKeyDown: $.noop, //callback to implement autocomplete on certain keys for example. args => event, buffer, caretPos, opts
-		onBeforeMask: null, //executes before masking the initial value to allow preprocessing of the initial value.	args => initialValue, opts => return processedValue
-		onBeforePaste: function (pastedValue, opts) {
-			return $.isFunction(opts.onBeforeMask) ? opts.onBeforeMask.call(this, pastedValue, opts) : pastedValue;
-		}, //executes before masking the pasted value to allow preprocessing of the pasted value.	args => pastedValue, opts => return processedValue
-		onBeforeWrite: null, //executes before writing to the masked element. args => event, opts
-		onUnMask: null, //executes after unmasking to allow postprocessing of the unmaskedvalue.	args => maskedValue, unmaskedValue, opts
-		showMaskOnFocus: true, //show the mask-placeholder when the input has focus
-		showMaskOnHover: true, //show the mask-placeholder when hovering the empty input
-		onKeyValidation: $.noop, //executes on every key-press with the result of isValid. Params: key, result, opts
-		skipOptionalPartCharacter: " ", //a character which can be used to skip an optional part of a mask
-		numericInput: false, //numericInput input direction style (input shifts to the left while holding the caret position)
-		rightAlign: false, //align to the right
-		undoOnEscape: true, //pressing escape reverts the value to the value before focus
-		//numeric basic properties
-		radixPoint: "", //".", // | ","
-		_radixDance: false, //dance around the radixPoint
-		groupSeparator: "", //",", // | "."
-		//numeric basic properties
-		keepStatic: null, //try to keep the mask static while typing. Decisions to alter the mask will be posponed if possible
-		positionCaretOnTab: true, //when enabled the caret position is set after the latest valid position on TAB
-		tabThrough: false, //allows for tabbing through the different parts of the masked field
-		supportsInputType: ["text", "tel", "url", "password", "search"], //list with the supported input types
-		//specify keyCodes which should not be considered in the keypress event, otherwise the preventDefault will stop their default behavior especially in FF
-		ignorables: [8, 9, 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, //override for isComplete - args => buffer, opts - return true || false
-		preValidation: null, //hook to preValidate the input.  Usefull for validating regardless the definition.	args => buffer, pos, char, isSelection, opts, maskset, caretPos, strict => return true/false/command object
-		postValidation: null, //hook to postValidate the result from isValid.	Usefull for validating the entry as a whole.	args => buffer, pos, c, currentResult, opts, maskset, strict => return true/false/json
-		staticDefinitionSymbol: undefined, //specify a definitionSymbol for static content, used to make matches for alternators
-		jitMasking: false, //just in time masking ~ only mask while typing, can n (number), true or false
-		nullable: true, //return nothing instead of the buffertemplate when the user hasn't entered anything.
-		inputEventOnly: false, //dev option - testing inputfallback behavior
-		noValuePatching: false, //disable value property patching
-		positionCaretOnClick: "lvp", //none, lvp (based on the last valid position (default), radixFocus (position caret to radixpoint on initial click), select (select the whole input), ignore (ignore the click and continue the mask)
-		casing: null, //mask-level casing. Options: null, "upper", "lower" or "title" or callback args => elem, test, pos, validPositions return charValue
-		inputmode: "text", //specify the inputmode
-		importDataAttributes: true, //import data-inputmask attributes
-		shiftPositions: true //shift position of the mask entries on entry and deletion.
-	},
-	definitions: {
-		"9": { //\uFF11-\uFF19 #1606
-			validator: "[0-9\uFF11-\uFF19]",
-			definitionSymbol: "*"
-		},
-		"a": { //\u0410-\u044F\u0401\u0451\u00C0-\u00FF\u00B5 #76
-			validator: "[A-Za-z\u0410-\u044F\u0401\u0451\u00C0-\u00FF\u00B5]",
-			definitionSymbol: "*"
-		},
-		"*": {
-			validator: "[0-9\uFF11-\uFF19A-Za-z\u0410-\u044F\u0401\u0451\u00C0-\u00FF\u00B5]"
-		}
-	},
+	defaults: defaults,
+	definitions: definitions,
 	aliases: {}, //aliases definitions
 	masksCache: {},
+	get isRTL() {
+		return this.opts.isRTL || this.opts.numericInput;
+	},
 	mask: function (elems) {
 		var that = this;
 		if (typeof elems === "string") {
 			elems = document.getElementById(elems) || document.querySelectorAll(elems);
 		}
-		elems = elems.nodeName ? [elems] : elems;
-		$.each(elems, function (ndx, el) {
+		elems = elems.nodeName ? [elems] : (Array.isArray(elems) ? elems : Array.from(elems));
+		elems.forEach(function (el, ndx) {
 			var scopedOpts = $.extend(true, {}, that.opts);
 			if (importAttributeOptions(el, scopedOpts, $.extend(true, {}, that.userOptions), that.dataAttribute)) {
 				var maskset = generateMaskSet(scopedOpts, that.noMasksCache);
@@ -137,15 +95,13 @@ Inputmask.prototype = {
 					el.inputmask.opts = scopedOpts;
 					el.inputmask.noMasksCache = that.noMasksCache;
 					el.inputmask.userOptions = $.extend(true, {}, that.userOptions);
-					el.inputmask.isRTL = scopedOpts.isRTL || scopedOpts.numericInput;
+					// el.inputmask.isRTL = scopedOpts.isRTL || scopedOpts.numericInput;
 					el.inputmask.el = el;
+					el.inputmask.$el = $(el);
 					el.inputmask.maskset = maskset;
 
-					$.data(el, "_inputmask_opts", scopedOpts);
-
-					maskScope.call(el.inputmask, {
-						"action": "mask"
-					});
+					$.data(el, dataKey, that.userOptions);
+					mask.call(el.inputmask);
 				}
 			}
 		});
@@ -165,51 +121,101 @@ Inputmask.prototype = {
 	},
 	unmaskedvalue: function (value) {
 		this.maskset = this.maskset || generateMaskSet(this.opts, this.noMasksCache);
-		return maskScope.call(this, {
-			"action": "unmaskedvalue",
-			"value": value
-		});
+		if (this.el === undefined || value !== undefined) {
+			var valueBuffer = (typeof this.opts.onBeforeMask === "function" ? (this.opts.onBeforeMask.call(this, value, this.opts) || value) : value).split("");
+			checkVal.call(this, undefined, false, false, valueBuffer);
+			if (typeof this.opts.onBeforeWrite === "function") this.opts.onBeforeWrite.call(this, undefined, getBuffer.call(this), 0, this.opts);
+		}
+		return unmaskedvalue.call(this, this.el);
 	},
 	remove: function () {
-		return maskScope.call(this, {
-			"action": "remove"
-		});
+		if (this.el) {
+			$.data(this.el, dataKey, null); //invalidate
+			//writeout the value
+			var cv = this.opts.autoUnmask ? unmaskedvalue(this.el) : this._valueGet(this.opts.autoUnmask);
+			if (cv !== getBufferTemplate.call(this).join("")) this._valueSet(cv, this.opts.autoUnmask); else this._valueSet("");
+			//unbind all events
+			EventRuler.off(this.el);
+
+			//restore the value property
+			var valueProperty;
+			if (Object.getOwnPropertyDescriptor && Object.getPrototypeOf) {
+				valueProperty = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(this.el), "value");
+				if (valueProperty) {
+					if (this.__valueGet) {
+						Object.defineProperty(this.el, "value", {
+							get: this.__valueGet,
+							set: this.__valueSet,
+							configurable: true
+						});
+					}
+				}
+			} else if (document.__lookupGetter__ && this.el.__lookupGetter__("value")) {
+				if (this.__valueGet) {
+					this.el.__defineGetter__("value", this.__valueGet);
+					this.el.__defineSetter__("value", this.__valueSet);
+				}
+			}
+			//clear data
+			this.el.inputmask = undefined;
+		}
+		return this.el;
 	},
 	getemptymask: function () { //return the default (empty) mask value, usefull for setting the default value in validation
 		this.maskset = this.maskset || generateMaskSet(this.opts, this.noMasksCache);
-		return maskScope.call(this, {
-			"action": "getemptymask"
-		});
+		return getBufferTemplate.call(this).join("");
 	},
 	hasMaskedValue: function () { //check wheter the returned value is masked or not; currently only works reliable when using jquery.val fn to retrieve the value
 		return !this.opts.autoUnmask;
 	},
 	isComplete: function () {
 		this.maskset = this.maskset || generateMaskSet(this.opts, this.noMasksCache);
-		return maskScope.call(this, {
-			"action": "isComplete"
-		});
+		return isComplete.call(this, getBuffer.call(this));
 	},
 	getmetadata: function () { //return mask metadata if exists
 		this.maskset = this.maskset || generateMaskSet(this.opts, this.noMasksCache);
-		return maskScope.call(this, {
-			"action": "getmetadata"
-		});
+		if (Array.isArray(this.maskset.metadata)) {
+			var maskTarget = getMaskTemplate.call(this, true, 0, false).join("");
+			this.maskset.metadata.forEach(function (mtdt) {
+				if (mtdt.mask === maskTarget) {
+					maskTarget = mtdt;
+					return false;
+				}
+
+				return true;
+			});
+			return maskTarget;
+		}
+		return this.maskset.metadata;
 	},
 	isValid: function (value) {
 		this.maskset = this.maskset || generateMaskSet(this.opts, this.noMasksCache);
-		return maskScope.call(this, {
-			"action": "isValid",
-			"value": value
-		});
+		if (value) {
+			var valueBuffer = (typeof this.opts.onBeforeMask === "function" ? (this.opts.onBeforeMask.call(this, value, this.opts) || value) : value).split("");
+			checkVal.call(this, undefined, true, false, valueBuffer);
+		} else {
+			value = this.isRTL ? getBuffer.call(this).slice().reverse().join("") : getBuffer.call(this).join("");
+		}
+		var buffer = getBuffer.call(this);
+		var rl = determineLastRequiredPosition.call(this),
+			lmib = buffer.length - 1;
+		for (; lmib > rl; lmib--) {
+			if (isMask.call(this, lmib)) break;
+		}
+		buffer.splice(rl, lmib + 1 - rl);
+
+		return isComplete.call(this, buffer) && value === (this.isRTL ? getBuffer.call(this).slice().reverse().join("") : getBuffer.call(this).join(""));
+
 	},
 	format: function (value, metadata) {
 		this.maskset = this.maskset || generateMaskSet(this.opts, this.noMasksCache);
-		return maskScope.call(this, {
-			"action": "format",
-			"value": value,
-			"metadata": metadata //true/false getmetadata
-		});
+		let valueBuffer = (typeof this.opts.onBeforeMask === "function" ? (this.opts.onBeforeMask.call(this, value, this.opts) || value) : value).split("");
+		checkVal.call(this, undefined, true, false, valueBuffer);
+		let formattedValue = this.isRTL ? getBuffer.call(this).slice().reverse().join("") : getBuffer.call(this).join("");
+		return metadata ? {
+			value: formattedValue,
+			metadata: this.getmetadata()
+		} : formattedValue;
 	},
 	setValue: function (value) {
 		if (this.el) {
@@ -227,16 +233,17 @@ function resolveAlias(aliasStr, options, opts) {
 		$.extend(true, opts, options); //reapply extra given options
 		return true;
 	} else //alias not found - try as mask
-		if (opts.mask === null) {
-			opts.mask = aliasStr;
-		}
+	if (opts.mask === null) {
+		opts.mask = aliasStr;
+	}
 
 	return false;
 }
 
 function importAttributeOptions(npt, opts, userOptions, dataAttribute) {
 	function importOption(option, optionData) {
-		optionData = optionData !== undefined ? optionData : npt.getAttribute(dataAttribute + "-" + option);
+		const attrOption = dataAttribute === "" ? option : dataAttribute + "-" + option;
+		optionData = optionData !== undefined ? optionData : npt.getAttribute(attrOption);
 		if (optionData !== null) {
 			if (typeof optionData === "string") {
 				if (option.indexOf("on") === 0) {
@@ -327,7 +334,7 @@ Inputmask.remove = function (elems) {
 		elems = document.getElementById(elems) || document.querySelectorAll(elems);
 	}
 	elems = elems.nodeName ? [elems] : elems;
-	$.each(elems, function (ndx, el) {
+	elems.forEach(function (el) {
 		if (el.inputmask) el.inputmask.remove();
 	});
 };
@@ -336,17 +343,13 @@ Inputmask.setValue = function (elems, value) {
 		elems = document.getElementById(elems) || document.querySelectorAll(elems);
 	}
 	elems = elems.nodeName ? [elems] : elems;
-	$.each(elems, function (ndx, el) {
+	elems.forEach(function (el) {
 		if (el.inputmask) el.inputmask.setValue(value); else $(el).trigger("setvalue", [value]);
 	});
 };
-var escapeRegexRegex = new RegExp("(\\" + ["/", ".", "*", "+", "?", "|", "(", ")", "[", "]", "{", "}", "\\", "$", "^"].join("|\\") + ")", "gim");
-Inputmask.escapeRegex = function (str) {
-	return str.replace(escapeRegexRegex, "\\$1");
-};
 
 Inputmask.dependencyLib = $;
 
 //make inputmask available
 window.Inputmask = Inputmask;
-module.exports = Inputmask;
+export default Inputmask;